/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  numDefineFloat35,
  numDefine98,
  numDefine99,
  numDefine100,
  numDefine101,
  numDefine102,
  numDefine103,
  numDefine540,
  numDefine128,
  numDefine140,
  numDefine107,
  numDefine111,
  numDefine145,
  numDefine146,
  numDefine147,
  numDefine148,
  numDefine108,
  numDefine109,
  numDefine110,
  numDefine104,
  numDefine105,
  numDefine106,
  numDefine28,
  numDefine2,
  numDefine13,
  numDefine19,
  numDefine18,
  numDefine3,
  numDefine16,
  numDefine5,
  numDefine6,
  numDefine7,
  numDefine8,
  numDefine135,
  numDefine136,
  numDefine137,
  numDefine138,
  numDefine139,
  numDefine141,
  numDefine142,
  numDefine143,
  numDefine144,
  numDefine149,
  numDefine150,
  numDefine151,
  numDefine152,
  numDefine153,
  numDefine154,
  numDefine155,
  numDefine156,
  numDefine157,
  numDefine158,
  numDefine159,
  numDefine160,
  numDefine161,
  numDefine162,
  numDefine163,
  numDefine164,
  numDefine165,
  numDefine166,
  numDefine720,
  numDefine721,
  numDefine723,
  numDefine724,
  numDefine725,
  numDefine183,
  numDefine172,
  numDefine173,
  numDefine170,
  numDefine171,
  numDefine169,
  numDefine722,
  numDefine179,
  numDefineFloat132,
  numDefineNegFloat265,
  numDefineFloat265,
  numDefine29,
  numDefine20,
  numDefine14,
  numDefine72,
  numDefine73,
  numDefine74,
  numDefine75,
  numDefine76,
  numDefine77,
  numDefine78,
  numDefine79,
  numDefine80,
  numDefine81,
  numDefine82,
  numDefine83,
  numDefine84,
  numDefine85,
  numDefine86,
  numDefine87,
  numDefine88,
  numDefine89,
  numDefine90,
  numDefine91,
  numDefine92,
  numDefine93,
  numDefine94,
  numDefine95,
  numDefine96,
  numDefine97,
  numDefine30,
  numDefine21,
  numDefine31,
  numDefine22,
  numDefine32,
  numDefine23,
  numDefine33,
  numDefine10,
  numDefine9,
  numDefine4,
  numDefine15,
  numDefine11,
  numDefine48,
  numDefineNeg2,
  numDefine46,
  numDefineNeg8,
  numDefine56,
  numDefine64,
  numDefine58,
  numDefine65535,
  numDefineNeg16,
  numDefine27,
  numDefine17,
  numDefine12,
  numDefine255,
  numDefineNeg24,
  numDefine54,
  numDefineNeg4,
  numDefine24,
  numDefineNeg40,
  numDefineNeg6,
  numDefineNeg12,
  numDefineNeg3,
  numDefine40,
  numDefine47,
  numDefine36,
  numDefine61,
  numDefine50,
  numDefine25,
  numDefine67,
  numDefine26,
  numDefine63,
  numDefine38,
  numDefine42,
  numDefine71,
  numDefine39,
  numDefine45,
  numDefine34,
  numDefine43,
  numDefine44,
  numDefine49,
  numDefine68,
  numDefine65,
  numDefine41,
  numDefine57,
  numDefine52,
  numDefine51,
  numDefine35,
  numDefine37,
  numDefine120,
  numDefine53,
  numDefine1024,
  numDefine60,
  numDefineNeg5,
  numDefineNeg83648,
  numDefine122,
  numDefineNeg36,
  numDefine62,
  numDefine117,
  numDefine121,
  numDefineFloat05,
  numDefineNeg112,
  numDefineNeg80,
  numDefineNeg20,
  numDefineNeg64,
  numDefineNeg160,
  numDefineNeg1024,
  numDefine512,
  numDefine200,
  numDefine10006,
  numDefine10001,
  numDefine10005,
  numDefine10004,
  numDefine10003,
  numDefine10002,
  numDefineNeg96,
  numDefineNegFloat028,
  numDefineNeg43,
  numDefineNeg25,
  numDefineFloat179,
  numDefineNegFloat006,
  numDefineNeg168,
  numDefineNeg152,
  numDefineNeg38,
  numDefine55,
  numDefine59,
  numDefine492,
  numDefineNeg41432,
  numDefine332,
  numDefine240,
  numDefine4095,
  numDefine1140,
  numDefine1346,
  numDefine2000,
  numDefineNeg3501,
  numDefine3501,
  numDefineNeg24112,
  numDefine24048,
  numDefine220,
  numDefine246,
  numDefine264,
  numDefine245,
  numDefine244,
  numDefineNeg41280,
  numDefineNeg10320,
  numDefineNeg41416,
  numDefineNeg10354,
  numDefineNeg41300,
  numDefineNeg41264,
  numDefine10000,
  numDefine10007,
  numDefine10008,
  numDefine10009,
  numDefine10010,
  numDefine10011,
  numDefineFloat074,
  numDefine2500,
  numDefine4000,
  numDefine4001,
  numDefine4002,
  numDefine4003,
  numDefine2002,
  numDefine8000,
  numDefine8001,
  numDefine8002,
  numDefine8003,
  numDefine500,
  numDefine16000,
  numDefine24000,
  numDefine32000,
  numDefineNeg176,
  numDefineNeg44,
  numDefineNeg18,
  numDefineFloat15,
  numDefineFloat068,
  numDefine14013,
  numDefine31011,
  numDefine32767,
  numDefine448,
  numDefineNeg1152,
  numDefineNeg288,
  numDefineNeg1216,
  numDefineNeg304,
  numDefineNegFloat352,
  numDefineNeg256,
  numDefineNeg1040,
  numDefineNeg260,
  numDefineFloat009,
  numDefineFloat037,
  numDefineNeg284,
  numDefineNeg1120,
  numDefineNeg280,
  numDefineNeg1104,
  numDefineNeg276,
  numDefineNeg1088,
  numDefineNeg272,
  numDefineNeg1072,
  numDefineNeg268,
  numDefineNeg1056,
  numDefineNeg264,
  numDefineNeg944,
  numDefineNeg236,
  numDefineNeg960,
  numDefineNeg240,
  numDefineFloat952,
  numDefineFloat941,
  numDefineFloat176,
  numDefineFloat919,
  numDefineFloat063,
  numDefineFloat249,
  numDefineFloat584,
  numDefineFloat225,
  numDefineFloat604,
  numDefineFloat049,
  numDefineNeg880,
  numDefineNeg220,
  numDefineNeg816,
  numDefineNeg204,
  numDefineNeg752,
  numDefineNeg188,
  numDefineNeg688,
  numDefineNeg172,
  numDefineNegFloat642,
  numDefineNeg624,
  numDefineNeg156,
  numDefineNeg560,
  numDefineNeg140,
  numDefineFloat642,
  numDefineNeg496,
  numDefineNeg124,
  numDefineNeg432,
  numDefineNeg108,
  numDefineNegFloat279,
  numDefineNeg368,
  numDefineNeg92,
  numDefineNegFloat458,
  numDefineNeg76,
  numDefineFloat279,
  numDefineNeg60,
  numDefineFloat458,
  numDefine116,
  numDefineNeg11,
  numDefineNegFloat132,
  numDefine127,
  numDefine175,
  numDefineNeg1136,
  numDefine260,
  numDefine272,
  numDefine41824,
  numDefine53216,
  numDefine2003,
  numDefine2001,
  numDefineNegFloat267,
  numDefine379,
  numDefine9999,
  numDefine627,
  numDefine4096,
  numDefine5388,
  numDefine28027,
  numDefine748,
  numDefine596,
  numDefine495,
  numDefineNeg30432,
  numDefine58986,
  numDefine75494,
  numDefine64608,
  numDefine97773,
  numDefine93162,
  numDefine81770,
  numDefine44395,
  numDefine67991,
  numDefine69459,
  numDefine27699,
  numDefine46080,
  numDefine24083,
  numDefine42330,
  numDefine53722,
  numDefine04800,
  numDefine20557,
  numDefine31949,
  numDefine36634,
  numDefine66243,
  numDefine04362,
  numDefine16192,
  numDefine14848,
  numDefine82127,
  numDefine30432,
  numDefine84039,
  numDefine31443,
  numDefine54227,
  numDefine40456,
  numDefine88057,
  numDefine42835,
  numDefine39248,
  numDefine64843,
  numDefine94025,
  numDefine67456,
  numDefine43341,
  numDefine86381,
  numDefine38976,
  numDefine18619,
  numDefine41403,
  numDefine72647,
  numDefine20051,
  numDefine52795,
  numDefine39282,
  numDefine29064,
  numDefine39283,
  numDefine45646,
  numDefine41678,
  numDefineNeg57408,
  numDefineNeg37568,
  numDefineNeg13270,
  numDefineNeg67456,
  numDefineNeg68800,
  numDefineNeg30578,
  numDefineNeg41824,
  numDefineNeg99609,
  numDefineNeg30853,
  numDefineNeg54584,
  numDefineNeg44364,
  numDefineNeg44366,
  numDefineNeg38002,
  numDefineNeg52205,
  numDefineNeg95591,
  numDefineNeg44365,
  numDefineNeg41970,
  numDefineNeg63597,
  numDefineNeg42245
} from './mandreel-part1/Class/DevNumber';

import {
  fmodf,
  free,
  dump,
  fillPtrFromString,
  cosf,
  mallocNew,
  uint,
  llvmWriteDouble,
  sinf,
  assertNew,
  znwj,
  zdlPv,
  sqrtf,
  getTimeOfDay,
  getStringFromPtr,
  MandreelCanvas,
  MandreelCanvasDiv,
  pause,
  gStackPointer,
  functionTable,
  zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb,
  znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i,
  zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb,
  swriteIndex
} from './commonFile';

import { commonVariable, heapClassInst, nullMandreelAudio, mandreelAudioUseMusicFunctions } from './mandreel-part1/Class/CommonClassFile';

import { mandreelDocument, MandreelDocument } from './mandreel-part1/Class/MandreelDocument';
import { MandreelElement } from './mandreel-part1/Class/MandreelElement';
import {
  gDisableDeactivation,
  gNumAlignedAllocs,
  gNumAlignedFree,
  landscapeIdx,
  landscapeIdxCount,
  landscapeVtx,
  landscapeVtxCount,
  memcpy,
  printf,
  twoEStr11,
  twoEStr112,
  twoEStr3,
  twoEStr4,
  twoEStr5,
  twoEStr573,
  twoEStr6,
  twoEStr674,
  twoEStr7,
  zgvzn11btMatrix3x311getIdentityEvE14identityMatrix,
  zgvzn11btTransform11getIdentityEvE17identityTransform,
  zl10raycastBar,
  zl14benchmarkDemo4,
  zl7TaruVtx,
  zl8nextRand,
  ztv10btBoxShape,
  ztv11btRigidBody,
  ztv12btAxisSweep3,
  ztv13BenchmarkDemo,
  ztv13btSphereShape,
  ztv14BenchmarkDemo4,
  ztv14btCapsuleShape,
  ztv15btNullPairCache,
  ztv16btCollisionWorld,
  ztv16btDbvtBroadphase,
  ztv16btManifoldResult,
  ztv17btHingeConstraint,
  ztv19btTriangleMeshShape,
  ztv20btAxisSweep3InternalItE,
  ztv20btDefaultMotionState,
  ztv21btCollisionDispatcher,
  ztv21btConeTwistConstraint,
  ztv22btBvhTriangleMeshShape,
  ztv23btDiscreteDynamicsWorld,
  ztv25btSimulationIslandManager,
  ztv26btTriangleIndexVertexArray,
  ztv30btGjkEpaPenetrationDepthSolver,
  ztv31btDefaultCollisionConfiguration,
  ztv35btSequentialImpulseConstraintSolver,
  ztv7RagDoll,
  ztvn16btCollisionWorld24ClosestRayResultCallbackE,
  ztvn16btEmptyAlgorithm10CreateFuncE,
  ztvn23btConvexConvexAlgorithm10CreateFuncE,
  ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE,
  ztvn28btCompoundCollisionAlgorithm10CreateFuncE,
  ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE,
  ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE,
  ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE,
  ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE,
  ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE,
  ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE,
  zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0,
  zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1,
  zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2,
  zzn11btTransform11getIdentityEvE17identityTransform,
  mandreelFlashTcpOnError
} from './commonFile';

import { zn28btHashedOverlappingPairCacheC1Ev } from './mandreelFile2';
import {
  zn17btConvexHullShape8addPointERK9btVector3,
  zn17btConvexHullShapeC1EPKfii,
  zn22btBvhTriangleMeshShape17buildOptimizedBvhEv,
  znk10btBoxShape21calculateLocalInertiaEfR9btVector3
} from './mandreelFile4';
import { zn19btTriangleMeshShape15recalcLocalAabbEv } from './mandreelFile5';
import { zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE } from './mandreelFile6';
import { mandreelFlashTcpOnConnect, mandreelFlashTcpReceiveCallbak } from './mandreelFile7';

import {
  zn13BenchmarkDemo11exitPhysicsEv,
  zn15DemoApplication16getDynamicsWorldEv,
  znk16btCollisionWorld17RayResultCallback14needsCollisionEP17btBroadphaseProxy,
  zn16btCollisionWorld24ClosestRayResultCallbackD1Ev,
  zn16btCollisionWorld24ClosestRayResultCallbackD0Ev,
  zn20btDefaultMotionStateD1Ev,
  zn20btDefaultMotionStateD0Ev,
  zn15DemoApplication6myinitEv,
  znk20btDefaultMotionState17getWorldTransformER11btTransform,
  zn13BenchmarkDemoD1Ev,
  zn20btDefaultMotionState17setWorldTransformERK11btTransform,
  zn13BenchmarkDemo15displayCallbackEv,
  zn7RagDollD0Ev,
  zn7RagDollD1Ev,
  zn13BenchmarkDemoD0Ev,
  zn15DemoApplication20localCreateRigidBodyEfRK11btTransformP16btCollisionShape,
  zn13BenchmarkDemo20clientMoveAndDisplayEv
} from './mandreelFile8';

class GetChanne {
  length: number = 0;

  getChannelData(num: number): string {
    return String(num);
  }
}

class WebkitAudioContext {
  destination: string = '';

  createBuffer(response: string, bool: boolean): void {}
}

class VariableSet {
  mandreelTotalPogfileSize: number = 0;
  gMandreelTimestampFs: number = 0;
  preCreatedWebAudioContext: null | WebkitAudioContext = null;
  gMandreelFs: GmandreelFs | null = null;
}

let webAudioContext: WebkitAudioContext = new WebkitAudioContext();
let webAudioUseMusicFunctions: boolean = true;
let webAudioBuffers: string[] = new Array();
let webAudioChannels: number[] = new Array(numDefine32);
let webAudioGain: number[] = new Array(numDefine32);
let waMandreelCacheAudioFilesPath: string = '';
let variableSet: VariableSet = new VariableSet();

class GmandreelFs {
  root: string | null = '';
}

let gMandreelFs: GmandreelFs = new GmandreelFs();
let gMandreelTimestampFs: number = 0.0;
let webAudioPreloadAudioFiles: string[] = new Array();
let webAudioPreloadCurrentFile: number = 0;
let webAudioPreloadAsync: boolean = false;

let waMandreelAudioBuffersNum: number = 0;
let waMandreelAudioBuffersLoaded: number = 0;

let mwebAudioPreloadState: string = 'start';
let mwebAudioPreloadAssets: Array<string> = new Array();
let mwebAudioCurrentPreloadAsset: number = 0;
let mwebAudioAsyncFiles: string | null = '';
let mwebListAudioAsyncFiles: string | null = '';
let mwebListAudioAsyncFilesPos: number = 0;
let mwebTotalPreloadingFiles: number = 0;
let mwebCurrentPreloadingFiles: number = 0;
let mandreelTotalPogfileSize: number = 0;

let waMandreelMusicElement: MandreelElement | null;
let waMandreelMusicElementFilename: string = '';

class Navigator {
  appName: string = '';
  userAgent: string = '';
}

let navigator: Navigator = new Navigator();
let waMandreelMusicElementVolume: number = 1.0;
let mandreelAudioStreamFuncPtr: number = 0;
let mandreelAudioCreateStreamCreated: boolean = false;

let mandreelFlashaudioServer: string | null = null;
let mandreelFlashaudioLite: boolean = false;
let mandreelFlashaudioMusicaudiotag: boolean = true;
let mandreelAudioFlashLastBufferCreated: number = 0;
let mandreelAudioFlashLastBufferCreatedSwf: number = 0;
let ninjaLoaded: boolean = false;

let maudiotagPreloadState: string = 'start';
let maudiotagPreloadAssets: Array<string> = new Array();
let maudiotagCurrentPreloadAsset: number = 0;
let maudiotagPreloadAsync: boolean = false;
let maudiotagDurations: Array<number> = new Array();
let maudiotagChannelsCreated: number = 0;
let maudiotagChannelsLoaded: Array<number> = Array();
let maudiotagAudioSpriteFound: boolean = false;
let audiotagAudioSprite: string = '';
let jsMandreelFlashSocketSwfLoaded: boolean = false;

function mandreelStartAudio(audioServer: string | null, audioUrl: string | null): void {
  let webAudioDataAvailable: boolean = false;
  let flashAudioDataAvailable: boolean = false;
  let flashLiteAudioDataAvailable: boolean = false;
  let audiotagsDataAvailable: boolean = false;
  if (flashAudioDataAvailable && commonVariable.mandreelAudioDriver === 'null') {
    commonVariable.mandreelAudioDriver = 'flash';
    flMainAudioDriver(audioServer, audioUrl);
  }
  if (flashLiteAudioDataAvailable && commonVariable.mandreelAudioDriver === 'null') {
    commonVariable.mandreelAudioDriver = 'flashlite';
    mandreelFlashaudioLite = true;
    flMainAudioDriver('', '');
  }
  if (audiotagsDataAvailable && commonVariable.mandreelAudioDriver === 'null') {
    commonVariable.mandreelAudioDriver = 'audiotag';
    atMainAudioDriver();
  }
  if (commonVariable.mandreelAudioDriver === 'null') {
    nullMainAudioDriver();
  }
  dump('AudioDriver (' + commonVariable.mandreelAudioDriver + ')');
}

function waMandreelAudioCreateBuffer(sp: number): void {
  let spTemp = sp;
  let ptrFileName: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let maxChannels: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName: string = getStringFromPtr(ptrFileName).toLowerCase();
  waImpMandreelAudioCreateBuffer(fileName);

  commonVariable.rg0 = 0;
}

function waMandreelAudioSetChannelVolume(sp: number): void {
  let spTemp = sp;
  let channel: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let vol: number = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  waImpMandreelAudioSetChannelVolume(channel, vol);
}

function waMandreelAudioSetChannelPan(sp: number): void {
  let spTemp = sp;
  let channel: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pan: number = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
}

function waMandreelAudioSetChannelPitch(sp: number): void {
  let spTemp = sp;
  let channel: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pitch: number = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  waImpMandreelAudioSetChannelPitch(channel, pitch);
}

function waMandreelAudioUseMusicFunctions(sp: number): void {
  commonVariable.rg0 = webAudioUseMusicFunctions ? 1 : 0;
}

function waMandreelAudioPlayMusic(sp: number): void {
  let spTemp = sp;
  let ptrFileName: number = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName: string = getStringFromPtr(ptrFileName).toLowerCase();
  waImpMandreelAudioPlayMusic(fileName);
}

function waMandreelAudioStopMusic(sp: number): void {
  waImpMandreelAudioStopMusic();
}

function waMandreelAudioSetMusicVol(sp: number): void {
  let spTemp = sp;
  let vol: number = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  waImpMandreelAudioSetMusicVol(vol);
}

let mandreelAudioInit = nullMandreelAudio;
let mandreelAudioEnd = nullMandreelAudio;
let mandreelAudioUpdate = nullMandreelAudio;
let mandreelAudioCreateBuffer = nullMandreelAudio;
let mandreelAudioPlayChannel = nullMandreelAudio;
let mandreelAudioStopChannel = nullMandreelAudio;
let mandreelAudioSetChannelVolume = nullMandreelAudio;
let mandreelAudioSetChannelPan = nullMandreelAudio;
let mandreelAudioSetChannelPitch = nullMandreelAudio;
let mandreelAudioPlayMusic = nullMandreelAudio;
let mandreelAudioStopMusic = nullMandreelAudio;
let mandreelAudioUseMusicFunctionsNew = mandreelAudioUseMusicFunctions;
let mandreelAudioCheckBuffersPending = nullMandreelAudio;
let mandreelAudioSetMusicVol = nullMandreelAudio;

function waInitWebAudio(): void {
  if (variableSet.preCreatedWebAudioContext !== null) {
    webAudioContext = variableSet.preCreatedWebAudioContext;
  }
}

function waGetFileNameNoExt(fileName: string): string {
  let fileNameNoExt: string = fileName.toLowerCase();
  return fileNameNoExt;
}

function waImpMandreelAudioCheckBuffersPending(): number {
  return waMandreelAudioBuffersNum - waMandreelAudioBuffersLoaded;
}

function waImpMandreelAudioCreateBuffer(fileName: string): void {
  if (webAudioContext !== null) {
    let fileNameNoExt = waGetFileNameNoExt(fileName);
    let buffer: string = webAudioBuffers[fileNameNoExt];
    if (buffer === null && buffer !== 'invalid') {
      waMandreelAudioBuffersNum += 1;
    }
  }
}

function waImpMandreelAudioSetChannelVolume(channel: number, vol: number): void {
  if (webAudioContext !== null) {
    let gain = webAudioGain[channel];
    if (gain !== null) {
      gain = vol;
    }
  }
}

function waImpMandreelAudioSetChannelPitch(channel: number, pitch: number): void {
  if (webAudioContext !== null) {
    let chn = webAudioChannels[channel];
    if (chn !== null) {
      chn = pitch;
    }
  }
}

function mwebCallbackAsync(): void {
  mwebListAudioAsyncFilesPos += 1;
  if (mwebListAudioAsyncFilesPos >= mwebListAudioAsyncFiles!.length) {
    mwebListAudioAsyncFiles = null;
    mwebAudioAsyncFiles = null;
    return;
  }
}

function mwebCallbackAsyncPreload(): void {
  mwebCurrentPreloadingFiles += 1;
}

function mandreelWebAudioPreloadAssets(): void {}

function waImpMandreelAudioPlayMusic(fileName: string): void {
  let fileNameNoExt = waGetFileNameNoExt(fileName);
  let fileNameFull = commonVariable.gMandreelWorkingFolder + fileNameNoExt + '.ogg';

  if (waMandreelMusicElementFilename !== fileNameFull) {
    waImpMandreelAudioStopMusic();
    let audio: MandreelElement = mandreelDocument.createElement('audio');
    waMandreelMusicElement = audio;
    waMandreelMusicElementFilename = fileNameFull;
  }
}

function waImpMandreelAudioStopMusic(): void {
  if (waMandreelMusicElement !== null) {
    waMandreelMusicElement = null;
    waMandreelMusicElementFilename = '';
  }
}

function waImpMandreelAudioSetMusicVol(vol: number): void {
  waMandreelMusicElementVolume = vol;
  if (waMandreelMusicElement !== null) {
    waMandreelMusicElement.volume = waMandreelMusicElementVolume;
  }
}

function mandreelAudioRequestSoundData(soundData: string): void {
  let n = soundData.length / numDefine2;
  let offset2 = 0;
  while (n > 0) {
    let n2 = n;
    if (n2 > numDefine1024) {
      n2 = numDefine1024;
    }
    let sp = gStackPointer + numDefine100 * numDefine1024;
    let ptr = gStackPointer + numDefine200 * numDefine1024;
    let spNew = sp >> numDefine2;
    heapClassInst.heap32[spNew] = ptr;
    heapClassInst.heap32[spNew + 1] = n2;
    functionTable[mandreelAudioStreamFuncPtr >> numDefine2](sp);

    let offset = ptr >> numDefine2;
    let size = n2 * numDefine2;
    offset2 += n2 * numDefine2;
    n -= n2;
  }
}

function mandreelSendmsgFlash(msg: string): void {
  if (mandreelFlashaudioServer !== '') {
    let iframeWin = mandreelDocument.getElementById('ninja-iframe')!.contentWindow;
  }
}

function flMandreelAudioInit(sp: number): void {
  mandreelSendmsgFlash('init ' + commonVariable.gMandreelWorkingFolder);
}

function mandreelFlashaudioliteCreateBuffer(fileName: string): void {
  mandreelAudioFlashLastBufferCreated += 1;
  mandreelSendmsgFlash('createBuffer ' + waGetFileNameNoExt(fileName) + ' ' + mandreelAudioFlashLastBufferCreated);
}

function flMandreelAudioCreateBuffer(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName = getStringFromPtr(Number(ptrFileName)).toLowerCase();
  mandreelFlashaudioliteCreateBuffer(fileName);
}

function flInternalMandreelAudioCheckBuffersPending(): boolean {
  return mandreelFlashaudioLite && mandreelAudioFlashLastBufferCreatedSwf !== mandreelAudioFlashLastBufferCreated;
}

function flMandreelAudioCheckBuffersPending(sp: number): void {
  commonVariable.rg0 = 0;
  if (flInternalMandreelAudioCheckBuffersPending()) {
    commonVariable.rg0 = 1;
  }
  dump(
    'flMandreelAudioCheckBuffersPending (' +
    String(commonVariable.rg0) +
    ') (' +
    String(mandreelAudioFlashLastBufferCreatedSwf) +
    ') (' +
    String(mandreelAudioFlashLastBufferCreated) +
    ')'
  );
}

function flMandreelAudioPlayChannel(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let vol = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  let loop = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName = getStringFromPtr(ptrFileName).toLowerCase();
  mandreelSendmsgFlash('playChannel ' + fileName + ' ' + String(channel) + ' ' + String(loop) + ' ' + String(vol) + ' ' + String(pitch));
  commonVariable.rg0 = 0;
}

function flMandreelAudioStopChannel(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let index = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;

  mandreelSendmsgFlash('stopChannel ' + channel);
}

function flMandreelAudioSetChannelVolume(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let vol = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;

  mandreelSendmsgFlash('setChannelVolume ' + String(channel) + ' ' + String(vol));
}

function flMandreelAudioSetChannelPan(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pan = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  mandreelSendmsgFlash('setChannelPan ' + String(channel) + ' ' + String(pan));
}

function flMandreelAudioSetChannelPitch(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  mandreelSendmsgFlash('setChannelPitch ' + String(channel) + ' ' + String(pitch));
}

function flMainAudioDriver(audioServer: string | null, audioUrl: string | null): void {
  mandreelFlashaudioServer = audioServer;
  if (mandreelFlashaudioLite) {
    mandreelFlashaudioServer = '';
  }
}

function flMapMandreelAudioFunctions(): void {
  mandreelAudioInit = flMandreelAudioInit;
  mandreelAudioCreateBuffer = flMandreelAudioCreateBuffer;
  mandreelAudioPlayChannel = flMandreelAudioPlayChannel;
  mandreelAudioStopChannel = flMandreelAudioStopChannel;
  mandreelAudioSetChannelVolume = flMandreelAudioSetChannelVolume;
  mandreelAudioSetChannelPan = flMandreelAudioSetChannelPan;
  mandreelAudioSetChannelPitch = flMandreelAudioSetChannelPitch;
  if (mandreelFlashaudioMusicaudiotag) {
    mandreelAudioUseMusicFunctionsNew = waMandreelAudioUseMusicFunctions;
    mandreelAudioPlayMusic = waMandreelAudioPlayMusic;
    mandreelAudioStopMusic = waMandreelAudioStopMusic;
    mandreelAudioSetMusicVol = waMandreelAudioSetMusicVol;
  } else {
    dump('WARNING: flash music functions not supported');
  }
  mandreelAudioCheckBuffersPending = flMandreelAudioCheckBuffersPending;
}

function receiveMessage2(event: string): void {
  ninjaLoaded = true;
  flMapMandreelAudioFunctions();
}

function flashReady(): void {
  flMapMandreelAudioFunctions();
}

function nullMainAudioDriver(): void {
  mandreelAudioInit = nullMandreelAudio;
  mandreelAudioEnd = nullMandreelAudio;
  mandreelAudioUpdate = nullMandreelAudio;
  mandreelAudioCreateBuffer = nullMandreelAudio;
  mandreelAudioPlayChannel = nullMandreelAudio;
  mandreelAudioStopChannel = nullMandreelAudio;
  mandreelAudioSetChannelVolume = nullMandreelAudio;
  mandreelAudioSetChannelPan = nullMandreelAudio;
  mandreelAudioSetChannelPitch = nullMandreelAudio;
  mandreelAudioUseMusicFunctionsNew = waMandreelAudioUseMusicFunctions;
  mandreelAudioPlayMusic = waMandreelAudioPlayMusic;
  mandreelAudioStopMusic = waMandreelAudioStopMusic;
  mandreelAudioSetMusicVol = waMandreelAudioSetMusicVol;
}

function atMandreelAudioCheckBuffersPending(sp: number): void {
  commonVariable.rg0 = 0;
}

function atMandreelAudioCreateBuffer(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let maxChannels = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName = getStringFromPtr(ptrFileName).toLowerCase();
  commonVariable.rg0 = 0;
}

function atMandreelAudioPlayChannel(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let vol = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  let loop = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
  let fileName = getStringFromPtr(Number(ptrFileName)).toLowerCase();
  commonVariable.rg0 = 0;
}

function atMandreelAudioStopChannel(sp: number): void {
  let spTemp = sp;
  let ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let index = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
}

function atMandreelAudioSetChannelVolume(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let vol = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
}

function atMandreelAudioSetChannelPan(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pan = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
}

function atMandreelAudioSetChannelPitch(sp: number): void {
  let spTemp = sp;
  let channel = heapClassInst.heap32[spTemp >> numDefine2];
  spTemp += numDefine4;
  let pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
  spTemp += numDefine4;
}

function atmandreelAudioUseMusicFunctions(sp: number): void {
  commonVariable.rg0 = 1;
}

function atMainAudioDriver(): void {
  mandreelAudioCreateBuffer = atMandreelAudioCreateBuffer;
  mandreelAudioPlayChannel = atMandreelAudioPlayChannel;
  mandreelAudioStopChannel = atMandreelAudioStopChannel;
  mandreelAudioSetChannelVolume = atMandreelAudioSetChannelVolume;
  mandreelAudioSetChannelPan = atMandreelAudioSetChannelPan;
  mandreelAudioSetChannelPitch = atMandreelAudioSetChannelPitch;
  mandreelAudioUseMusicFunctionsNew = atmandreelAudioUseMusicFunctions;
  mandreelAudioPlayMusic = waMandreelAudioPlayMusic;
  mandreelAudioStopMusic = waMandreelAudioStopMusic;
  mandreelAudioCheckBuffersPending = atMandreelAudioCheckBuffersPending;
  mandreelAudioSetMusicVol = waMandreelAudioSetMusicVol;
}

function jsMandreelFlashSocketReady(): void {
  jsMandreelFlashSocketSwfLoaded = true;
}

function jsMandreelFlashSocketOnError(message: string): void {
  let id = Number(message);

  let sp = gStackPointer + numDefine512 * numDefine1024;

  dump('on error ' + String(id));

  heapClassInst.heap32[sp >> numDefine2] = id;
  mandreelFlashTcpOnError(sp);
}

function globalILandscape02Vtx(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zl10raycastBar;
  heapClassInst.heap32[g0] = numDefine8;
  r0 = r0 >> numDefine2;
  znwj(i7);
  heapClassInst.heap32[r0 + numDefine10006] = commonVariable.rg0;
  heapClassInst.heap32[g0] = commonVariable.rg0;
  heapClassInst.heap32[g0 + 1] = 0;
  getTimeOfDay(i7);
  heapClassInst.heap32[r0 + numDefine10001] = 0;
  heapClassInst.heap32[r0 + numDefine10005] = 0;
  heapClassInst.heap32[r0 + numDefine10004] = numDefine9999;
  heapClassInst.heap32[r0 + numDefine10003] = 0;
  heapClassInst.heap32[r0 + numDefine10002] = 0;
  return;
}

function globalDLandscape02Vtx(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zl10raycastBar;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine10006];
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn17btTypedConstraint21setupSolverConstraintER20btAlignedObjectArrayI18btSolverConstraintEiif(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;

  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn17btTypedConstraint23solveConstraintObsoleteER11btRigidBodyS1F(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn13BenchmarkDemo10createWallERK9btVector3iS2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg96;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = gNumAlignedAllocs;
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  f0 = heapClassInst.heapFloat[r0 + numDefine2];
  f1 = heapClassInst.heapFloat[r0 + 1];
  f2 = heapClassInst.heapFloat[r0];
  r2 = (r2 + 1) | 0;
  heapClassInst.heap32[r1] = r2;
  heapClassInst.heap32[g0] = numDefine71;
  mallocNew(i7);
  r1 = commonVariable.rg0;
  r2 = heapClassInst.heap32[fp];
  if (r1 !== 0) {
    r3 = 0;
    r4 = (r1 + numDefine4) | 0;
    r3 = (r3 - r4) | 0;
    r3 = r3 & numDefine15;
    r3 = (r1 + r3) | 0;
    r4 = (r3 + numDefine4) | 0;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r3] = r1;
    r1 = r4;
  }
  r3 = r1 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine2] = 0;
  heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
  heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
  r4 = ztv10btBoxShape;
  heapClassInst.heap32[r3 + numDefine6] = 0;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
  heapClassInst.heap32[r3] = r4;
  f3 = numDefineNegFloat028;
  f2 = f2 + f3;
  heapClassInst.heap32[r3 + 1] = 0;
  f1 = f1 + f3;
  heapClassInst.heapFloat[r3 + numDefine7] = f2;
  f0 = f0 + f3;
  heapClassInst.heapFloat[r3 + numDefine8] = f1;
  heapClassInst.heapFloat[r3 + numDefine9] = f0;
  r4 = sp + numDefineNeg16;
  heapClassInst.heap32[r3 + numDefine10] = 0;
  r3 = r4 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg4] = 0;
  heapClassInst.heap32[r3 + 1] = 0;
  heapClassInst.heap32[r3 + numDefine2] = 0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine53216;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
  f4 = heapClassInst.heapFloat[r0 + 1];
  f0 = heapClassInst.heapFloat[r0 + numDefine2];
  r0 = sp + numDefineNeg80;
  r3 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg20] = numDefine53216;
  heapClassInst.heap32[r3 + 1] = 0;
  heapClassInst.heap32[r3 + numDefine2] = 0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  heapClassInst.heap32[r3 + numDefine4] = 0;
  heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r3 + numDefine6] = 0;
  heapClassInst.heap32[r3 + numDefine7] = 0;
  heapClassInst.heap32[r3 + numDefine8] = 0;
  heapClassInst.heap32[r3 + numDefine9] = 0;
  heapClassInst.heap32[r3 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r3 + numDefine11] = 0;
  f1 = f0 + f0;
  f2 = numDefineNeg12;
  heapClassInst.heap32[r3 + numDefine12] = 0;
  heapClassInst.heap32[r3 + numDefine13] = 0;
  f2 = f1 * f2;
  f3 = numDefineFloat05;
  f3 = f2 * f3;
  f2 = f4 + f4;
  r5 = numDefine12;
  heapClassInst.heap32[r3 + numDefine14] = 0;
  heapClassInst.heap32[r3 + numDefine15] = 0;
  repeat4: while (true) {
    if (!(r5 < 1)) {
      r4 = 0;
      repeat8: while (true) {
        r6 = r2 >> numDefine2;
        f5 = r4;
        f6 = 0;
        f7 = heapClassInst.heapFloat[r6];
        f8 = heapClassInst.heapFloat[r6 + numDefine2];
        f9 = heapClassInst.heapFloat[r6 + 1];
        f5 = f5 * f1;
        f6 = f7 + f6;
        f5 = f5 + f3;
        f7 = f9 + f4;
        heapClassInst.heapFloat[r3 + numDefine12] = f6;
        f5 = f8 + f5;
        heapClassInst.heapFloat[r3 + numDefine13] = f7;
        r6 = zl14benchmarkDemo4;
        heapClassInst.heapFloat[r3 + numDefine14] = f5;
        r7 = r6 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine15] = 0;
        r7 = heapClassInst.heap32[r7];
        r7 = r7 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine2];
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = numDefine53216;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        r4 = (r4 + 1) | 0;
        functionTable[r7 >> numDefine2](i7);
        if (r5 !== r4) {
          continue repeat8;
        } else {
          break repeat8;
        }
      }
    }
    r5 = (r5 + -1) | 0;
    f4 = f4 + f2;
    f3 = f3 + f0;
    if (r5 === 0) {
      break repeat4;
    } else {
      continue repeat4;
    }
  }
  return;
}

function zn13BenchmarkDemo19createLargeMeshBodyEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg80;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg64;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
  heapClassInst.heap32[r1 + 1] = 0;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  heapClassInst.heap32[r1 + numDefine8] = 0;
  heapClassInst.heap32[r1 + numDefine9] = 0;
  heapClassInst.heap32[r1 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine11] = 0;
  heapClassInst.heap32[r1 + numDefine12] = 0;
  heapClassInst.heap32[r1 + numDefine13] = 0;
  r2 = 0;
  heapClassInst.heap32[r1 + numDefine14] = 0;
  heapClassInst.heap32[r1 + numDefine15] = 0;
  repeat1: while (true) {
    r3 = gNumAlignedAllocs;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r5 = (r4 + 1) | 0;
    heapClassInst.heap32[r3] = r5;
    heapClassInst.heap32[g0] = numDefine103;
    mallocNew(i7);
    r5 = commonVariable.rg0;
    if (r5 !== 0) {
      r6 = 0;
      r7 = (r5 + numDefine4) | 0;
      r6 = (r6 - r7) | 0;
      r6 = r6 & numDefine15;
      r6 = (r5 + r6) | 0;
      r7 = (r6 + numDefine4) | 0;
      r6 = r6 >> numDefine2;
      heapClassInst.heap32[r6] = r5;
      r5 = r7;
    }
    r6 = r5 >> numDefine2;
    heapClassInst.heap32[r6 + 1] = numDefine53216;
    heapClassInst.heap32[r6 + numDefine2] = numDefine53216;
    r7 = ztv26btTriangleIndexVertexArray;
    heapClassInst.heap32[r6 + numDefine3] = numDefine53216;
    r7 = (r7 + numDefine8) | 0;
    heapClassInst.heap32[r6 + numDefine4] = 0;
    r8 = 1;
    heapClassInst.heap32[r6] = r7;
    heapClassInst.heap8[r5 + numDefine36] = r8;
    heapClassInst.heap32[r6 + numDefine8] = 0;
    heapClassInst.heap32[r6 + numDefine6] = 0;
    r7 = landscapeVtx;
    r9 = r2 << numDefine2;
    r10 = landscapeVtxCount;
    r11 = landscapeIdx;
    r12 = landscapeIdxCount;
    r7 = (r7 + r9) | 0;
    r10 = (r10 + r9) | 0;
    r11 = (r11 + r9) | 0;
    r9 = (r12 + r9) | 0;
    heapClassInst.heap32[r6 + numDefine7] = 0;
    r7 = r7 >> numDefine2;
    heapClassInst.heap32[r6 + numDefine12] = 0;
    r10 = r10 >> numDefine2;
    r11 = r11 >> numDefine2;
    r9 = r9 >> numDefine2;
    r7 = heapClassInst.heap32[r7];
    r10 = heapClassInst.heap32[r10];
    r11 = heapClassInst.heap32[r11];
    r9 = heapClassInst.heap32[r9];
    r12 = (r4 + numDefine2) | 0;
    heapClassInst.heap32[r3] = r12;
    heapClassInst.heap32[g0] = numDefine51;
    mallocNew(i7);
    r12 = commonVariable.rg0;
    r9 = (r9 / numDefine3) | 0;
    if (r12 !== 0) {
      r13 = 0;
      r14 = (r12 + numDefine4) | 0;
      r13 = (r13 - r14) | 0;
      r13 = r13 & numDefine15;
      r13 = (r12 + r13) | 0;
      r14 = (r13 + numDefine4) | 0;
      r13 = r13 >> numDefine2;
      heapClassInst.heap32[r13] = r12;
      r12 = r14;
    }
    heapClassInst.heap8[r5 + numDefine36] = r8;
    heapClassInst.heap32[r6 + numDefine8] = r12;
    heapClassInst.heap32[r6 + numDefine7] = 1;
    r13 = heapClassInst.heap32[r6 + numDefine6];
    r13 = r13 << numDefine5;
    r12 = (r12 + r13) | 0;
    r12 = r12 >> numDefine2;
    heapClassInst.heap32[r12] = r9;
    heapClassInst.heap32[r12 + 1] = r11;
    heapClassInst.heap32[r12 + numDefine2] = numDefine6;
    heapClassInst.heap32[r12 + numDefine3] = r10;
    heapClassInst.heap32[r12 + numDefine4] = r7;
    heapClassInst.heap32[r12 + numDefine5] = numDefine12;
    heapClassInst.heap32[r12 + numDefine6] = numDefine3;
    heapClassInst.heap32[r12 + numDefine7] = 0;
    r7 = heapClassInst.heap32[r6 + numDefine6];
    r9 = (r7 + 1) | 0;
    heapClassInst.heap32[r6 + numDefine6] = r9;
    r7 = r7 << numDefine5;
    r9 = heapClassInst.heap32[r6 + numDefine8];
    r7 = (r9 + r7) | 0;
    r7 = r7 >> numDefine2;
    r4 = (r4 + numDefine3) | 0;
    heapClassInst.heap32[r7 + numDefine6] = numDefine3;
    heapClassInst.heap32[r3] = r4;
    heapClassInst.heap32[g0] = numDefine95;
    mallocNew(i7);
    r3 = commonVariable.rg0;
    if (r3 !== 0) {
      r4 = 0;
      r7 = (r3 + numDefine4) | 0;
      r4 = (r4 - r7) | 0;
      r4 = r4 & numDefine15;
      r4 = (r3 + r4) | 0;
      r7 = (r4 + numDefine4) | 0;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r4] = r3;
      r3 = r7;
    }
    r4 = r3 >> numDefine2;
    r7 = ztv19btTriangleMeshShape;
    heapClassInst.heap32[r4 + numDefine2] = 0;
    r7 = (r7 + numDefine8) | 0;
    heapClassInst.heap32[r4 + numDefine3] = 0;
    heapClassInst.heap32[r4] = r7;
    heapClassInst.heap32[r4 + numDefine12] = r5;
    heapClassInst.heap32[r4 + 1] = numDefine21;
    r7 = heapClassInst.heap32[r6];
    r7 = r7 >> numDefine2;
    r7 = heapClassInst.heap32[r7 + numDefine10];
    heapClassInst.heap32[g0] = r5;
    functionTable[r7 >> numDefine2](i7);
    r7 = commonVariable.rg0;
    if (r7 === 0) {
      heapClassInst.heap32[g0] = r3;
      zn19btTriangleMeshShape15recalcLocalAabbEv(i7);
    } else {
      r6 = heapClassInst.heap32[r6];
      r6 = r6 >> numDefine2;
      r6 = heapClassInst.heap32[r6 + numDefine12];
      r7 = (r3 + numDefine16) | 0;
      r9 = (r3 + numDefine32) | 0;
      heapClassInst.heap32[g0] = r5;
      heapClassInst.heap32[g0 + 1] = r7;
      heapClassInst.heap32[g0 + numDefine2] = r9;
      functionTable[r6 >> numDefine2](i7);
    }
    r5 = ztv22btBvhTriangleMeshShape;
    r5 = (r5 + numDefine8) | 0;
    heapClassInst.heap32[r4] = r5;
    heapClassInst.heap32[r4 + numDefine13] = 0;
    heapClassInst.heap32[r4 + numDefine14] = 0;
    r5 = 0;
    heapClassInst.heap8[r3 + numDefine60] = r8;
    heapClassInst.heap8[r3 + numDefine61] = r5;
    heapClassInst.heap32[r4 + 1] = numDefine21;
    heapClassInst.heap32[g0] = r3;
    zn22btBvhTriangleMeshShape17buildOptimizedBvhEv(i7);
    heapClassInst.heap32[r1 + numDefine12] = 0;
    heapClassInst.heap32[r1 + numDefine13] = numDefineNeg57408;
    r4 = zl14benchmarkDemo4;
    heapClassInst.heap32[r1 + numDefine14] = 0;
    r5 = r4 >> numDefine2;
    heapClassInst.heap32[r1 + numDefine15] = 0;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine2];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = 0;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    functionTable[r5 >> numDefine2](i7);
    r2 = (r2 + 1) | 0;
    r3 = commonVariable.rg0 >> numDefine2;
    heapClassInst.heap32[r3 + numDefine56] = numDefine75494;
    if (r2 !== numDefine8) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  return;
}

function zn13BenchmarkDemo11createTest6Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = gNumAlignedAllocs;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r1 = (r1 + 1) | 0;
  heapClassInst.heap32[r0] = r1;
  heapClassInst.heap32[g0] = numDefine127;
  mallocNew(i7);
  r0 = commonVariable.rg0;
  if (r0 !== 0) {
    r1 = 0;
    r2 = (r0 + numDefine4) | 0;
    r1 = (r1 - r2) | 0;
    r1 = r1 & numDefine15;
    r1 = (r0 + r1) | 0;
    r2 = (r1 + numDefine4) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r1] = r0;
    r0 = r2;
  }
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = 0;
  heapClassInst.heap32[g0 + numDefine2] = 0;
  r1 = 0;
  zn17btConvexHullShapeC1EPKfii(i7);
  repeat4: while (true) {
    r2 = (r1 * numDefineNeg3) | 0;
    r3 = zl7TaruVtx;
    r2 = r2 << numDefine2;
    r2 = (r3 + r2) | 0;
    r3 = sp + numDefineNeg96;
    r2 = r2 >> numDefine2;
    r4 = r3 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg24] = heapClassInst.heap32[r2];
    heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r2 + 1];
    heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r2 + numDefine2];
    heapClassInst.heap32[r4 + numDefine3] = 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r3;
    r1 = (r1 + -1) | 0;
    zn17btConvexHullShape8addPointERK9btVector3(i7);
    if (r1 === numDefineNeg43) {
      break repeat4;
    } else {
      continue repeat4;
    }
  }
  r1 = sp + numDefineNeg64;
  r2 = r1 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
  heapClassInst.heap32[r2 + 1] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r2 + numDefine6] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  r3 = sp + numDefineNeg80;
  heapClassInst.heap32[r2 + numDefine15] = 0;
  r4 = r3 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg20] = 0;
  heapClassInst.heap32[r4 + 1] = 0;
  heapClassInst.heap32[r4 + numDefine2] = 0;
  r5 = r0 >> numDefine2;
  heapClassInst.heap32[r4 + numDefine3] = 0;
  r4 = heapClassInst.heap32[r5];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine8];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = numDefine53216;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  r3 = numDefine10;
  f0 = numDefine20;
  f1 = numDefine2;
  f2 = numDefineNeg25;
  functionTable[r4 >> numDefine2](i7);
  r7 = zl14benchmarkDemo4;
  repeat7: while (true) {
    f3 = numDefine3;
    f4 = numDefine25;
    f5 = f1 + f3;
    f4 = f0 + f4;
    r4 = 0;
    r5 = r4;
    repeat9: while (true) {
      f6 = r5;
      f6 = f6 * f5;
      f6 = f6 + f2;
      f7 = numDefine5;
      f6 = f6 * f7;
      f8 = 0;
      f6 = f6 + f8;
      r6 = r4;
      repeat11: while (true) {
        f9 = r6;
        f9 = f9 * f5;
        f9 = f9 + f2;
        f9 = f9 * f7;
        f9 = f9 + f8;
        heapClassInst.heapFloat[r2 + numDefine12] = f9;
        heapClassInst.heapFloat[r2 + numDefine13] = f4;
        heapClassInst.heapFloat[r2 + numDefine14] = f6;
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine15] = 0;
        r8 = heapClassInst.heap32[r8];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine2];
        heapClassInst.heap32[g0] = r7;
        heapClassInst.heap32[g0 + 1] = numDefine53216;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        r6 = (r6 + 1) | 0;
        functionTable[r8 >> numDefine2](i7);
        if (r6 !== numDefine10) {
          continue repeat11;
        } else {
          break repeat11;
        }
      }
      r5 = (r5 + 1) | 0;
      if (r5 !== numDefine10) {
        continue repeat9;
      } else {
        break repeat9;
      }
    }
    f4 = numDefineFloat179;
    f5 = numDefineNegFloat006;
    f4 = f1 * f4;
    f1 = f1 * f5;
    f5 = numDefine9;
    f3 = f4 + f3;
    f1 = f1 * f5;
    r3 = (r3 + -1) | 0;
    f0 = f0 + f3;
    f2 = f1 + f2;
    f1 = f4;
    if (r3 === 0) {
      break repeat7;
    } else {
      continue repeat7;
    }
  }
  zn13BenchmarkDemo19createLargeMeshBodyEv(i7);
  return;
}

function zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg168;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg16;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg4] = 0;
  heapClassInst.heap32[r1 + 1] = 0;
  r2 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r1 + numDefine2] = 0;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine8];
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = numDefine53216;
  heapClassInst.heap32[g0 + numDefine2] = r0;
  r0 = zgvzn11btTransform11getIdentityEvE17identityTransform;
  functionTable[r3 >> numDefine2](i7);
  r3 = heapClassInst.heapU8[r0];
  if (!(r3 !== 0)) {
    r3 = zgvzn11btMatrix3x311getIdentityEvE14identityMatrix;
    r4 = heapClassInst.heapU8[r3];
    if (!(r4 !== 0)) {
      r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
      r5 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
      r4 = r4 >> numDefine2;
      r6 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
      r5 = r5 >> numDefine2;
      heapClassInst.heap32[r4] = numDefine53216;
      r4 = r6 >> numDefine2;
      heapClassInst.heap32[r5] = numDefine53216;
      r5 = 1;
      heapClassInst.heap32[r4] = numDefine53216;
      heapClassInst.heap8[r3] = r5;
    }
    r3 = zzn11btTransform11getIdentityEvE17identityTransform;
    r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
    r3 = r3 >> numDefine2;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r3] = heapClassInst.heap32[r4];
    heapClassInst.heap32[r3 + 1] = 0;
    heapClassInst.heap32[r3 + numDefine2] = 0;
    r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
    heapClassInst.heap32[r3 + numDefine3] = 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r3 + numDefine4] = 0;
    heapClassInst.heap32[r3 + numDefine5] = heapClassInst.heap32[r4];
    heapClassInst.heap32[r3 + numDefine6] = 0;
    heapClassInst.heap32[r3 + numDefine7] = 0;
    r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
    heapClassInst.heap32[r3 + numDefine8] = 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r3 + numDefine9] = 0;
    heapClassInst.heap32[r3 + numDefine10] = heapClassInst.heap32[r4];
    heapClassInst.heap32[r3 + numDefine11] = 0;
    heapClassInst.heap32[r3 + numDefine12] = 0;
    heapClassInst.heap32[r3 + numDefine13] = 0;
    heapClassInst.heap32[r3 + numDefine14] = 0;
    r4 = 1;
    heapClassInst.heap32[r3 + numDefine15] = 0;
    heapClassInst.heap8[r0] = r4;
  }
  r0 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = numDefine200;
  r4 = ztv20btDefaultMotionState;
  znwj(i7);
  r6 = commonVariable.rg0 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r6] = r4;
  heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r3];
  heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r3 + 1];
  heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
  heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r3 + numDefine4];
  heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r3 + numDefine5];
  heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r3 + numDefine6];
  heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r3 + numDefine7];
  heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r3 + numDefine8];
  heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r3 + numDefine9];
  heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r3 + numDefine9];
  heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r3 + numDefine10];
  heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r3 + numDefine11];
  heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r3 + numDefine12];
  heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r3 + numDefine13];
  r4 = zzn11btTransform11getIdentityEvE17identityTransform;
  heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r3 + numDefine14];
  r4 = r4 >> numDefine2;
  heapClassInst.heap32[r6 + numDefine16] = heapClassInst.heap32[r3 + numDefine15];
  heapClassInst.heap32[r6 + numDefine17] = heapClassInst.heap32[r4];
  heapClassInst.heap32[r6 + numDefine18] = heapClassInst.heap32[r4 + 1];
  heapClassInst.heap32[r6 + numDefine19] = heapClassInst.heap32[r4 + numDefine2];
  heapClassInst.heap32[r6 + numDefine20] = heapClassInst.heap32[r4 + numDefine3];
  heapClassInst.heap32[r6 + numDefine21] = heapClassInst.heap32[r4 + numDefine4];
  heapClassInst.heap32[r6 + numDefine22] = heapClassInst.heap32[r4 + numDefine5];
  heapClassInst.heap32[r6 + numDefine23] = heapClassInst.heap32[r4 + numDefine6];
  heapClassInst.heap32[r6 + numDefine24] = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[r6 + numDefine25] = heapClassInst.heap32[r4 + numDefine8];
  heapClassInst.heap32[r6 + numDefine26] = heapClassInst.heap32[r4 + numDefine9];
  heapClassInst.heap32[r6 + numDefine27] = heapClassInst.heap32[r4 + numDefine10];
  heapClassInst.heap32[r6 + numDefine28] = heapClassInst.heap32[r4 + numDefine11];
  heapClassInst.heap32[r6 + numDefine29] = heapClassInst.heap32[r4 + numDefine12];
  heapClassInst.heap32[r6 + numDefine30] = heapClassInst.heap32[r4 + numDefine13];
  heapClassInst.heap32[r6 + numDefine31] = heapClassInst.heap32[r4 + numDefine14];
  heapClassInst.heap32[r6 + numDefine32] = heapClassInst.heap32[r4 + numDefine15];
  heapClassInst.heap32[r6 + numDefine33] = heapClassInst.heap32[r3];
  heapClassInst.heap32[r6 + numDefine34] = heapClassInst.heap32[r3 + 1];
  heapClassInst.heap32[r6 + numDefine35] = heapClassInst.heap32[r3 + numDefine2];
  heapClassInst.heap32[r6 + numDefine36] = heapClassInst.heap32[r3 + numDefine3];
  heapClassInst.heap32[r6 + numDefine37] = heapClassInst.heap32[r3 + numDefine4];
  heapClassInst.heap32[r6 + numDefine38] = heapClassInst.heap32[r3 + numDefine5];
  heapClassInst.heap32[r6 + numDefine39] = heapClassInst.heap32[r3 + numDefine6];
  heapClassInst.heap32[r6 + numDefine40] = heapClassInst.heap32[r3 + numDefine7];
  heapClassInst.heap32[r6 + numDefine41] = heapClassInst.heap32[r3 + numDefine8];
  heapClassInst.heap32[r6 + numDefine42] = heapClassInst.heap32[r3 + numDefine9];
  heapClassInst.heap32[r6 + numDefine43] = heapClassInst.heap32[r3 + numDefine10];
  heapClassInst.heap32[r6 + numDefine44] = heapClassInst.heap32[r3 + numDefine11];
  heapClassInst.heap32[r6 + numDefine45] = heapClassInst.heap32[r3 + numDefine12];
  heapClassInst.heap32[r6 + numDefine46] = heapClassInst.heap32[r3 + numDefine13];
  heapClassInst.heap32[r6 + numDefine47] = heapClassInst.heap32[r3 + numDefine14];
  heapClassInst.heap32[r6 + numDefine48] = heapClassInst.heap32[r3 + numDefine15];
  r3 = sp + numDefineNeg152;
  heapClassInst.heap32[r6 + numDefine49] = 0;
  r4 = r3 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg38] = numDefine53216;
  heapClassInst.heap32[r4 + 1] = commonVariable.rg0;
  heapClassInst.heap32[r4 + numDefine18] = r2;
  heapClassInst.heap32[r4 + numDefine19] = heapClassInst.heap32[fp + numDefineNeg4];
  heapClassInst.heap32[r4 + numDefine20] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r4 + numDefine21] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r4 + numDefine22] = heapClassInst.heap32[r1 + numDefine3];
  heapClassInst.heap32[r4 + numDefine23] = 0;
  heapClassInst.heap32[r4 + numDefine24] = 0;
  heapClassInst.heap32[r4 + numDefine25] = numDefine64608;
  heapClassInst.heap32[r4 + numDefine26] = 0;
  heapClassInst.heap32[r4 + numDefine27] = numDefine97773;
  r1 = 0;
  heapClassInst.heap32[r4 + numDefine28] = numDefine53216;
  heapClassInst.heap8[sp + numDefineNeg36] = r1;
  heapClassInst.heap32[r4 + numDefine30] = numDefine93162;
  heapClassInst.heap32[r4 + numDefine31] = numDefine81770;
  heapClassInst.heap32[r4 + numDefine32] = numDefine81770;
  heapClassInst.heap32[r4 + numDefine33] = numDefine81770;
  heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
  heapClassInst.heap32[r4 + numDefine3] = 0;
  heapClassInst.heap32[r4 + numDefine4] = 0;
  heapClassInst.heap32[r4 + numDefine5] = 0;
  heapClassInst.heap32[r4 + numDefine6] = 0;
  heapClassInst.heap32[r4 + numDefine7] = numDefine53216;
  heapClassInst.heap32[r4 + numDefine8] = 0;
  heapClassInst.heap32[r4 + numDefine9] = 0;
  heapClassInst.heap32[r4 + numDefine10] = 0;
  heapClassInst.heap32[r4 + numDefine11] = 0;
  heapClassInst.heap32[r4 + numDefine12] = numDefine53216;
  heapClassInst.heap32[r4 + numDefine13] = 0;
  heapClassInst.heap32[r4 + numDefine14] = 0;
  heapClassInst.heap32[r4 + numDefine15] = 0;
  r2 = gNumAlignedAllocs;
  heapClassInst.heap32[r4 + numDefine16] = 0;
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r4 + numDefine17] = 0;
  r4 = heapClassInst.heap32[r2];
  r4 = (r4 + 1) | 0;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine627;
  mallocNew(i7);
  r2 = commonVariable.rg0;
  if (r2 !== 0) {
    r4 = (r2 + numDefine4) | 0;
    r1 = (r1 - r4) | 0;
    r1 = r1 & numDefine15;
    r1 = (r2 + r1) | 0;
    r4 = (r1 + numDefine4) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r1] = r2;
    r2 = r4;
  }
  r1 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine41] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine42] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine43] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine44] = 0;
  heapClassInst.heap32[r1 + numDefine45] = 0;
  heapClassInst.heap32[r1 + numDefine46] = numDefine44395;
  heapClassInst.heap32[r1 + numDefine47] = 0;
  heapClassInst.heap32[r1 + numDefine48] = 0;
  heapClassInst.heap32[r1 + numDefine49] = 0;
  heapClassInst.heap32[r1 + numDefine50] = 0;
  heapClassInst.heap32[r1 + numDefine51] = 1;
  heapClassInst.heap32[r1 + numDefine52] = -1;
  heapClassInst.heap32[r1 + numDefine53] = -1;
  heapClassInst.heap32[r1 + numDefine54] = 1;
  heapClassInst.heap32[r1 + numDefine55] = 0;
  heapClassInst.heap32[r1 + numDefine56] = numDefine64608;
  heapClassInst.heap32[r1 + numDefine57] = 0;
  heapClassInst.heap32[r1 + numDefine58] = 1;
  heapClassInst.heap32[r1 + numDefine59] = 0;
  heapClassInst.heap32[r1 + numDefine60] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine61] = 0;
  heapClassInst.heap32[r1 + numDefine62] = 0;
  heapClassInst.heap32[r1 + numDefine63] = 0;
  heapClassInst.heap32[r1 + 1] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine5] = 0;
  heapClassInst.heap32[r1 + numDefine6] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  heapClassInst.heap32[r1 + numDefine8] = 0;
  heapClassInst.heap32[r1 + numDefine9] = 0;
  heapClassInst.heap32[r1 + numDefine10] = 0;
  heapClassInst.heap32[r1 + numDefine11] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine12] = 0;
  heapClassInst.heap32[r1 + numDefine13] = 0;
  heapClassInst.heap32[r1 + numDefine14] = 0;
  r4 = ztv11btRigidBody;
  heapClassInst.heap32[r1 + numDefine15] = 0;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r1 + numDefine16] = 0;
  r5 = 1;
  heapClassInst.heap32[r1] = r4;
  heapClassInst.heap8[r2 + numDefine492] = r5;
  heapClassInst.heap32[r1 + numDefine122] = 0;
  heapClassInst.heap32[r1 + numDefine120] = 0;
  heapClassInst.heap32[r1 + numDefine121] = 0;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r3;
  zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine20];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  functionTable[r1 >> numDefine2](i7);
  commonVariable.rg0 = r2;
  return;
}

function zn13BenchmarkDemo11initPhysicsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg41432;
  let g0 = i7 >> numDefine2;
  heapClassInst.heap32[g0] = numDefine88;
  znwj(i7);
  r0 = commonVariable.rg0;
  r1 = ztv31btDefaultCollisionConfiguration;
  r2 = gNumAlignedAllocs;
  r3 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r3] = r1;
  r1 = heapClassInst.heap32[r2];
  r3 = (r1 + 1) | 0;
  heapClassInst.heap32[r2] = r3;
  heapClassInst.heap32[g0] = numDefine379;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = 0;
    r5 = (r3 + numDefine4) | 0;
    r4 = (r4 - r5) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r5 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r5;
  }
  r4 = r3 >> numDefine2;
  heapClassInst.heap32[r4 + numDefine77] = numDefine67991;
  r4 = heapClassInst.heapU8[r3 + numDefine332];
  r4 = r4 & numDefine240;
  r5 = r0 >> numDefine2;
  heapClassInst.heap8[r3 + numDefine332] = r4;
  r4 = (r1 + numDefine2) | 0;
  heapClassInst.heap32[r5 + numDefine8] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine23;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = 0;
    r6 = (r3 + numDefine4) | 0;
    r4 = (r4 - r6) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztv30btGjkEpaPenetrationDepthSolver;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine3) | 0;
  heapClassInst.heap32[r5 + numDefine9] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine43;
  mallocNew(i7);
  r4 = commonVariable.rg0;
  if (r4 !== 0) {
    r3 = 0;
    r6 = (r4 + numDefine4) | 0;
    r3 = (r3 - r6) | 0;
    r3 = r3 & numDefine15;
    r3 = (r4 + r3) | 0;
    r6 = r3 >> numDefine2;
    heapClassInst.heap32[r6] = r4;
    r4 = (r3 + numDefine4) | 0;
    r3 = heapClassInst.heap32[r5 + numDefine9];
  }
  r6 = ztvn23btConvexConvexAlgorithm10CreateFuncE;
  r7 = heapClassInst.heap32[r5 + numDefine8];
  r8 = 0;
  r9 = r4 >> numDefine2;
  r6 = (r6 + numDefine8) | 0;
  heapClassInst.heap8[r4 + numDefine4] = r8;
  heapClassInst.heap32[r9] = r6;
  heapClassInst.heap32[r9 + numDefine4] = 0;
  heapClassInst.heap32[r9 + numDefine5] = numDefine3;
  heapClassInst.heap32[r9 + numDefine3] = r7;
  heapClassInst.heap32[r9 + numDefine2] = r3;
  r3 = (r1 + numDefine4) | 0;
  heapClassInst.heap32[r5 + numDefine10] = r4;
  heapClassInst.heap32[r2] = r3;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine5) | 0;
  heapClassInst.heap32[r5 + numDefine11] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine6) | 0;
  heapClassInst.heap32[r5 + numDefine12] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn28btCompoundCollisionAlgorithm10CreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine7) | 0;
  heapClassInst.heap32[r5 + numDefine13] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r5 + numDefine14] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn16btEmptyAlgorithm10CreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine9) | 0;
  heapClassInst.heap32[r5 + numDefine15] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = (r1 + numDefine10) | 0;
  heapClassInst.heap32[r5 + numDefine16] = r3;
  heapClassInst.heap32[r2] = r4;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r4 = (r3 + numDefine4) | 0;
    r4 = (r8 - r4) | 0;
    r4 = r4 & numDefine15;
    r4 = (r3 + r4) | 0;
    r6 = (r4 + numDefine4) | 0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r4] = r3;
    r3 = r6;
  }
  r4 = ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
  r6 = r3 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r6 = (r1 + numDefine11) | 0;
  heapClassInst.heap32[r5 + numDefine18] = r3;
  heapClassInst.heap32[r2] = r6;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = r3 >> numDefine2;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r6] = r4;
  r4 = 1;
  heapClassInst.heap32[r5 + numDefine19] = r3;
  r6 = (r1 + numDefine12) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r4;
  heapClassInst.heap32[r2] = r6;
  heapClassInst.heap32[g0] = numDefine27;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE;
  r7 = r3 >> numDefine2;
  r6 = (r6 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r7] = r6;
  r6 = (r1 + numDefine13) | 0;
  heapClassInst.heap32[r5 + numDefine17] = r3;
  heapClassInst.heap32[r2] = r6;
  heapClassInst.heap32[g0] = numDefine35;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
  r7 = r3 >> numDefine2;
  r6 = (r6 + numDefine8) | 0;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r7] = r6;
  heapClassInst.heap32[r7 + numDefine2] = 1;
  heapClassInst.heap32[r7 + numDefine3] = 1;
  r7 = (r1 + numDefine14) | 0;
  heapClassInst.heap32[r5 + numDefine21] = r3;
  heapClassInst.heap32[r2] = r7;
  heapClassInst.heap32[g0] = numDefine35;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r7 = (r3 + numDefine4) | 0;
    r7 = (r8 - r7) | 0;
    r7 = r7 & numDefine15;
    r7 = (r3 + r7) | 0;
    r9 = (r7 + numDefine4) | 0;
    r7 = r7 >> numDefine2;
    heapClassInst.heap32[r7] = r3;
    r3 = r9;
  }
  r7 = r3 >> numDefine2;
  heapClassInst.heap8[r3 + numDefine4] = r8;
  heapClassInst.heap32[r7] = r6;
  heapClassInst.heap32[r7 + numDefine2] = 1;
  heapClassInst.heap32[r7 + numDefine3] = 1;
  heapClassInst.heap32[r5 + numDefine20] = r3;
  heapClassInst.heap8[r3 + numDefine4] = r4;
  r3 = (r1 + numDefine15) | 0;
  heapClassInst.heap8[r0 + numDefine12] = r4;
  heapClassInst.heap32[r2] = r3;
  heapClassInst.heap32[g0] = numDefine39;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = r3 >> numDefine2;
  heapClassInst.heap32[r6 + 1] = 0;
  heapClassInst.heap32[r6 + numDefine3] = 0;
  heapClassInst.heap8[r3 + numDefine16] = r8;
  heapClassInst.heap32[r6] = 0;
  r7 = (r1 + numDefine16) | 0;
  heapClassInst.heap32[r6 + numDefine2] = 0;
  heapClassInst.heap32[r2] = r7;
  heapClassInst.heap32[g0] = numDefine19;
  mallocNew(i7);
  r7 = commonVariable.rg0;
  if (r7 !== 0) {
    r9 = (r7 + numDefine4) | 0;
    r9 = (r8 - r9) | 0;
    r9 = r9 & numDefine15;
    r9 = (r7 + r9) | 0;
    r10 = (r9 + numDefine4) | 0;
    r9 = r9 >> numDefine2;
    heapClassInst.heap32[r9] = r7;
    r7 = r10;
  }
  heapClassInst.heap32[r6] = r7;
  heapClassInst.heap32[r6 + 1] = 0;
  heapClassInst.heap32[r5 + numDefine2] = r3;
  r3 = (r1 + numDefine17) | 0;
  heapClassInst.heap8[r0 + numDefine20] = r4;
  heapClassInst.heap32[r2] = r3;
  heapClassInst.heap32[g0] = numDefine39;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = r3 >> numDefine2;
  heapClassInst.heap32[r6] = numDefine1140;
  r7 = (r1 + numDefine18) | 0;
  heapClassInst.heap32[r6 + 1] = numDefine4096;
  heapClassInst.heap32[r2] = r7;
  heapClassInst.heap32[g0] = numDefine69459;
  mallocNew(i7);
  r7 = commonVariable.rg0;
  if (r7 !== 0) {
    r9 = (r7 + numDefine4) | 0;
    r9 = (r8 - r9) | 0;
    r9 = r9 & numDefine15;
    r9 = (r7 + r9) | 0;
    r10 = (r9 + numDefine4) | 0;
    r9 = r9 >> numDefine2;
    heapClassInst.heap32[r9] = r7;
    r7 = r10;
  }
  heapClassInst.heap32[r6 + numDefine4] = r7;
  r9 = numDefine4095;
  r10 = numDefine1140;
  heapClassInst.heap32[r6 + numDefine3] = r7;
  heapClassInst.heap32[r6 + numDefine2] = numDefine4096;
  r11 = r7;
  repeat55: while (true) {
    r7 = r7 >> numDefine2;
    r10 = (r11 + r10) | 0;
    heapClassInst.heap32[r7] = r10;
    r10 = heapClassInst.heap32[r6];
    r7 = (r11 + r10) | 0;
    r9 = (r9 + -1) | 0;
    r11 = r7;
    if (r9 !== 0) {
      continue repeat55;
    } else {
      break repeat55;
    }
  }
  r6 = r7 >> numDefine2;
  heapClassInst.heap32[r6] = 0;
  heapClassInst.heap32[r5 + numDefine4] = r3;
  r3 = (r1 + numDefine19) | 0;
  heapClassInst.heap8[r0 + numDefine28] = r4;
  heapClassInst.heap32[r2] = r3;
  heapClassInst.heap32[g0] = numDefine39;
  mallocNew(i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r6 = (r3 + numDefine4) | 0;
    r6 = (r8 - r6) | 0;
    r6 = r6 & numDefine15;
    r6 = (r3 + r6) | 0;
    r7 = (r6 + numDefine4) | 0;
    r6 = r6 >> numDefine2;
    heapClassInst.heap32[r6] = r3;
    r3 = r7;
  }
  r6 = r3 >> numDefine2;
  heapClassInst.heap32[r6] = numDefine80;
  r1 = (r1 + numDefine20) | 0;
  heapClassInst.heap32[r6 + 1] = numDefine4096;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = numDefine27699;
  mallocNew(i7);
  r1 = commonVariable.rg0;
  if (r1 !== 0) {
    r7 = (r1 + numDefine4) | 0;
    r7 = (r8 - r7) | 0;
    r7 = r7 & numDefine15;
    r7 = (r1 + r7) | 0;
    r9 = (r7 + numDefine4) | 0;
    r7 = r7 >> numDefine2;
    heapClassInst.heap32[r7] = r1;
    r1 = r9;
  }
  heapClassInst.heap32[r6 + numDefine4] = r1;
  r7 = numDefine4095;
  r9 = numDefine80;
  heapClassInst.heap32[r6 + numDefine3] = r1;
  heapClassInst.heap32[r6 + numDefine2] = numDefine4096;
  r10 = r1;
  repeat64: while (true) {
    r1 = r1 >> numDefine2;
    r9 = (r10 + r9) | 0;
    heapClassInst.heap32[r1] = r9;
    r9 = heapClassInst.heap32[r6];
    r1 = (r10 + r9) | 0;
    r7 = (r7 + -1) | 0;
    r10 = r1;
    if (r7 !== 0) {
      continue repeat64;
    } else {
      break repeat64;
    }
  }
  r1 = r1 >> numDefine2;
  r6 = zl14benchmarkDemo4;
  heapClassInst.heap32[r1] = 0;
  r1 = r6 >> numDefine2;
  heapClassInst.heap32[r5 + numDefine6] = r3;
  heapClassInst.heap32[r1 + numDefine16] = r0;
  heapClassInst.heap32[g0] = numDefine5388;
  znwj(i7);
  r0 = commonVariable.rg0;
  r3 = ztv21btCollisionDispatcher;
  r5 = heapClassInst.heap32[r1 + numDefine16];
  r3 = (r3 + numDefine8) | 0;
  r7 = r0 >> numDefine2;
  heapClassInst.heap32[r7] = r3;
  heapClassInst.heap32[r7 + 1] = numDefine2;
  heapClassInst.heap8[r0 + numDefine24] = r4;
  heapClassInst.heap32[r7 + numDefine5] = 0;
  r3 = ztv16btManifoldResult;
  heapClassInst.heap32[r7 + numDefine3] = 0;
  r3 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r7 + numDefine4] = 0;
  heapClassInst.heap32[r7 + numDefine7] = r3;
  r3 = swriteIndex.zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfoIndex;
  heapClassInst.heap32[r7 + numDefine1346] = r5;
  heapClassInst.heap32[r7 + numDefine47] = r3;
  r3 = r5 >> numDefine2;
  r9 = heapClassInst.heap32[r3];
  r9 = r9 >> numDefine2;
  r9 = heapClassInst.heap32[r9 + numDefine3];
  heapClassInst.heap32[g0] = r5;
  functionTable[r9 >> numDefine2](i7);
  heapClassInst.heap32[r7 + numDefine48] = commonVariable.rg0;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine2];
  heapClassInst.heap32[g0] = r5;
  functionTable[r3 >> numDefine2](i7);
  r5 = (r0 + numDefine200) | 0;
  heapClassInst.heap32[r7 + numDefine49] = commonVariable.rg0;
  repeat67: while (true) {
    if (r8 > numDefine35) {
      label = numDefine52;
      break repeat67;
    } else {
      r3 = 0;
      repeat70: while (true) {
        if (r3 < numDefine36) {
          r7 = r0 >> numDefine2;
          r7 = heapClassInst.heap32[r7 + numDefine1346];
          r9 = r7 >> numDefine2;
          r9 = heapClassInst.heap32[r9];
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefine5];
          r10 = r3 << numDefine2;
          heapClassInst.heap32[g0] = r7;
          heapClassInst.heap32[g0 + 1] = r8;
          heapClassInst.heap32[g0 + numDefine2] = r3;
          r7 = (r5 + r10) | 0;
          r7 = r7 >> numDefine2;
          functionTable[r9 >> numDefine2](i7);
          r9 = commonVariable.rg0;
          heapClassInst.heap32[r7] = r9;
          if (r9 !== 0) {
            r3 = (r3 + 1) | 0;
          } else {
            label = numDefine46;
            break repeat67;
          }
        } else {
          break repeat70;
        }
      }
      r8 = (r8 + 1) | 0;
      r5 = (r5 + numDefine144) | 0;
      continue repeat67;
    }
  }
  switch (label) {
    case numDefine52:
      heapClassInst.heap32[r1 + numDefine14] = r0;
      heapClassInst.heap32[g0] = numDefine76;
      znwj(i7);
      r0 = commonVariable.rg0;
      heapClassInst.heap32[g0] = r0;
      zn28btHashedOverlappingPairCacheC1Ev(i7);
      r3 = heapClassInst.heap32[r2];
      r5 = (r3 + 1) | 0;
      heapClassInst.heap32[r2] = r5;
      heapClassInst.heap32[g0] = numDefine135;
      mallocNew(i7);
      r7 = commonVariable.rg0;
      if (r7 !== 0) {
        r8 = 0;
        r9 = (r7 + numDefine4) | 0;
        r8 = (r8 - r9) | 0;
        r8 = r8 & numDefine15;
        r8 = (r7 + r8) | 0;
        r9 = (r8 + numDefine4) | 0;
        r8 = r8 >> numDefine2;
        heapClassInst.heap32[r8] = r7;
        r7 = r9;
      }
      r8 = ztv20btAxisSweep3InternalItE;
      r9 = r7 >> numDefine2;
      r8 = (r8 + numDefine8) | 0;
      r10 = numDefineNeg2;
      heapClassInst.heap32[r9] = r8;
      r8 = -1;
      heapClassInst.heap16[(r7 + numDefine4) >> 1] = r10;
      heapClassInst.heap16[(r7 + numDefine6) >> 1] = r8;
      heapClassInst.heap32[r9 + numDefine23] = r0;
      r8 = 0;
      heapClassInst.heap32[r9 + numDefine24] = 0;
      heapClassInst.heap8[r7 + numDefine100] = r8;
      heapClassInst.heap32[r9 + numDefine26] = 0;
      heapClassInst.heap32[r9 + numDefine27] = 0;
      if (r0 === 0) {
        r5 = (r3 + numDefine2) | 0;
        heapClassInst.heap32[r2] = r5;
        heapClassInst.heap32[g0] = numDefine95;
        mallocNew(i7);
        r5 = commonVariable.rg0;
        if (r5 !== 0) {
          r0 = 0;
          r3 = (r5 + numDefine4) | 0;
          r0 = (r0 - r3) | 0;
          r0 = r0 & numDefine15;
          r0 = (r5 + r0) | 0;
          r3 = (r0 + numDefine4) | 0;
          r0 = r0 >> numDefine2;
          heapClassInst.heap32[r0] = r5;
          r5 = r3;
        }
        heapClassInst.heap32[g0] = r5;
        zn28btHashedOverlappingPairCacheC1Ev(i7);
        heapClassInst.heap32[r9 + numDefine23] = r5;
        heapClassInst.heap8[r7 + numDefine100] = r4;
        r5 = heapClassInst.heap32[r2];
      }
      r0 = (r5 + 1) | 0;
      heapClassInst.heap32[r2] = r0;
      heapClassInst.heap32[g0] = numDefine43;
      mallocNew(i7);
      r0 = commonVariable.rg0;
      if (r0 !== 0) {
        r3 = (r0 + numDefine4) | 0;
        r3 = (r8 - r3) | 0;
        r3 = r3 & numDefine15;
        r3 = (r0 + r3) | 0;
        r10 = (r3 + numDefine4) | 0;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r3] = r0;
        r0 = r10;
      }
      r3 = ztv15btNullPairCache;
      r10 = r0 >> numDefine2;
      r3 = (r3 + numDefine8) | 0;
      heapClassInst.heap32[r10] = r3;
      heapClassInst.heap8[r0 + numDefine20] = r4;
      heapClassInst.heap32[r10 + numDefine4] = 0;
      heapClassInst.heap32[r10 + numDefine2] = 0;
      heapClassInst.heap32[r10 + numDefine3] = 0;
      r3 = (r5 + numDefine2) | 0;
      heapClassInst.heap32[r9 + numDefine28] = r0;
      heapClassInst.heap32[r2] = r3;
      heapClassInst.heap32[g0] = numDefine175;
      mallocNew(i7);
      r10 = commonVariable.rg0;
      if (r10 !== 0) {
        r11 = (r10 + numDefine4) | 0;
        r11 = (r8 - r11) | 0;
        r11 = r11 & numDefine15;
        r11 = (r10 + r11) | 0;
        r12 = (r11 + numDefine4) | 0;
        r11 = r11 >> numDefine2;
        heapClassInst.heap32[r11] = r10;
        r10 = r12;
      }
      r11 = ztv16btDbvtBroadphase;
      r12 = r10 >> numDefine2;
      r11 = (r11 + numDefine8) | 0;
      heapClassInst.heap32[r12] = r11;
      repeat92: while (true) {
        r11 = (r10 + r8) | 0;
        r13 = r11 >> numDefine2;
        heapClassInst.heap8[r11 + numDefine40] = r4;
        heapClassInst.heap32[r13 + numDefine9] = 0;
        heapClassInst.heap32[r13 + numDefine7] = 0;
        heapClassInst.heap32[r13 + numDefine8] = 0;
        heapClassInst.heap32[r13 + 1] = 0;
        heapClassInst.heap32[r13 + numDefine2] = 0;
        heapClassInst.heap32[r13 + numDefine3] = -1;
        r8 = (r8 + numDefine40) | 0;
        heapClassInst.heap32[r13 + numDefine4] = 0;
        heapClassInst.heap32[r13 + numDefine5] = 0;
        if (r8 !== numDefine80) {
          continue repeat92;
        } else {
          break repeat92;
        }
      }
      r8 = 0;
      r11 = (r0 === r8) ? 1 : 0;
      heapClassInst.heap8[r10 + numDefine153] = r8;
      r11 = r11 & 1;
      heapClassInst.heap8[r10 + numDefine154] = r4;
      heapClassInst.heap8[r10 + numDefine152] = r11;
      heapClassInst.heap32[r12 + numDefine25] = 0;
      heapClassInst.heap32[r12 + numDefine26] = 0;
      heapClassInst.heap32[r12 + numDefine31] = 0;
      heapClassInst.heap32[r12 + numDefine27] = 1;
      heapClassInst.heap32[r12 + numDefine28] = 0;
      heapClassInst.heap32[r12 + numDefine29] = numDefine10;
      heapClassInst.heap32[r12 + numDefine30] = 1;
      heapClassInst.heap32[r12 + numDefine32] = 0;
      heapClassInst.heap32[r12 + numDefine33] = 0;
      heapClassInst.heap32[r12 + numDefine34] = 0;
      if (r0 === 0) {
        r0 = (r5 + numDefine3) | 0;
        heapClassInst.heap32[r2] = r0;
        heapClassInst.heap32[g0] = numDefine95;
        mallocNew(i7);
        r0 = commonVariable.rg0;
        if (r0 !== 0) {
          r3 = 0;
          r5 = (r0 + numDefine4) | 0;
          r3 = (r3 - r5) | 0;
          r3 = r3 & numDefine15;
          r3 = (r0 + r3) | 0;
          r5 = (r3 + numDefine4) | 0;
          r3 = r3 >> numDefine2;
          heapClassInst.heap32[r3] = r0;
          r0 = r5;
        }
        heapClassInst.heap32[g0] = r0;
        zn28btHashedOverlappingPairCacheC1Ev(i7);
        r3 = heapClassInst.heap32[r2];
      }
      heapClassInst.heap32[r12 + numDefine24] = r0;
      heapClassInst.heap32[r12 + numDefine37] = 0;
      heapClassInst.heap32[r12 + numDefine35] = 0;
      heapClassInst.heap32[r12 + numDefine36] = 0;
      heapClassInst.heap32[r12 + numDefine21] = 0;
      heapClassInst.heap32[r12 + numDefine22] = 0;
      heapClassInst.heap32[r12 + numDefine23] = 0;
      heapClassInst.heap32[r9 + numDefine27] = r10;
      heapClassInst.heap8[r10 + numDefine153] = r4;
      heapClassInst.heap32[r9 + numDefine2] = numDefineNeg37568;
      heapClassInst.heap32[r9 + numDefine3] = numDefineNeg37568;
      heapClassInst.heap32[r9 + numDefine4] = numDefineNeg37568;
      heapClassInst.heap32[r9 + numDefine5] = 0;
      heapClassInst.heap32[r9 + numDefine6] = numDefine46080;
      heapClassInst.heap32[r9 + numDefine7] = numDefine46080;
      heapClassInst.heap32[r9 + numDefine8] = numDefine46080;
      heapClassInst.heap32[r9 + numDefine9] = 0;
      r0 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
      f0 = uint(r0);
      f1 = numDefine2000;
      f0 = f0 / f1;
      heapClassInst.heapFloat[r9 + numDefine10] = f0;
      heapClassInst.heapFloat[r9 + numDefine11] = f0;
      heapClassInst.heapFloat[r9 + numDefine12] = f0;
      r0 = (r3 + 1) | 0;
      heapClassInst.heap32[r9 + numDefine13] = 0;
      heapClassInst.heap32[r2] = r0;
      heapClassInst.heap32[g0] = numDefine24083;
      mallocNew(i7);
      r0 = commonVariable.rg0;
      if (r0 !== 0) {
        r5 = (r0 + numDefine4) | 0;
        r5 = (r8 - r5) | 0;
        r5 = r5 & numDefine15;
        r5 = (r0 + r5) | 0;
        r10 = (r5 + numDefine4) | 0;
        r5 = r5 >> numDefine2;
        heapClassInst.heap32[r5] = r0;
        r0 = r10;
      }
      repeat103: while (true) {
        r5 = r8 << numDefine6;
        r5 = (r0 - r5) | 0;
        r5 = r5 >> numDefine2;
        r8 = (r8 + -1) | 0;
        heapClassInst.heap32[r5] = 0;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        if (r8 !== numDefineNeg3501) {
          continue repeat103;
        } else {
          break repeat103;
        }
      }
      r5 = numDefine3501;
      heapClassInst.heap32[r9 + numDefine15] = r0;
      r8 = 0;
      heapClassInst.heap16[(r7 + numDefine58) >> 1] = r5;
      r5 = numDefineNeg112;
      r10 = numDefine2;
      heapClassInst.heap16[(r7 + numDefine56) >> 1] = r8;
      heapClassInst.heap16[(r7 + numDefine64) >> 1] = r4;
      repeat106: while (true) {
        r0 = (r0 - r5) | 0;
        heapClassInst.heap16[r0 >> 1] = r10;
        r5 = (r5 + numDefineNeg64) | 0;
        r0 = heapClassInst.heap32[r9 + numDefine15];
        r10 = (r10 + 1) | 0;
        if (r5 !== numDefineNeg24112) {
          continue repeat106;
        } else {
          break repeat106;
        }
      }
      r3 = (r3 + numDefine2) | 0;
      heapClassInst.heap16[(r0 + numDefine24048) >> 1] = r8;
      repeat109: while (true) {
        r0 = (r3 + r8) | 0;
        heapClassInst.heap32[r2] = r0;
        heapClassInst.heap32[g0] = numDefine28027;
        mallocNew(i7);
        r0 = commonVariable.rg0;
        if (r0 !== 0) {
          r5 = 0;
          r10 = (r0 + numDefine4) | 0;
          r5 = (r5 - r10) | 0;
          r5 = r5 & numDefine15;
          r5 = (r0 + r5) | 0;
          r10 = (r5 + numDefine4) | 0;
          r5 = r5 >> numDefine2;
          heapClassInst.heap32[r5] = r0;
          r0 = r10;
        }
        r5 = r8 << numDefine2;
        r5 = (r7 + r5) | 0;
        r5 = r5 >> numDefine2;
        r8 = (r8 + 1) | 0;
        heapClassInst.heap32[r5 + numDefine20] = r0;
        heapClassInst.heap32[r5 + numDefine17] = r0;
        if (r8 !== numDefine3) {
          continue repeat109;
        } else {
          break repeat109;
        }
      }
      r0 = heapClassInst.heap32[r9 + numDefine15];
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r0] = 0;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      r3 = 0;
      heapClassInst.heap16[(r0 + numDefine48) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      heapClassInst.heap16[(r0 + numDefine54) >> 1] = r4;
      r0 = heapClassInst.heap32[r9 + numDefine17];
      heapClassInst.heap16[r0 >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine17];
      heapClassInst.heap16[(r0 + numDefine2) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine17];
      r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
      heapClassInst.heap16[(r0 + numDefine4) >> 1] = r5;
      r0 = heapClassInst.heap32[r9 + numDefine17];
      heapClassInst.heap16[(r0 + numDefine6) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      heapClassInst.heap16[(r0 + numDefine50) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      heapClassInst.heap16[(r0 + numDefine56) >> 1] = r4;
      r0 = heapClassInst.heap32[r9 + numDefine18];
      heapClassInst.heap16[r0 >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine18];
      heapClassInst.heap16[(r0 + numDefine2) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine18];
      r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
      heapClassInst.heap16[(r0 + numDefine4) >> 1] = r5;
      r0 = heapClassInst.heap32[r9 + numDefine18];
      heapClassInst.heap16[(r0 + numDefine6) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      heapClassInst.heap16[(r0 + numDefine52) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine15];
      heapClassInst.heap16[(r0 + numDefine58) >> 1] = r4;
      r0 = heapClassInst.heap32[r9 + numDefine19];
      heapClassInst.heap16[r0 >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine19];
      heapClassInst.heap16[(r0 + numDefine2) >> 1] = r3;
      r0 = heapClassInst.heap32[r9 + numDefine19];
      r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
      heapClassInst.heap16[(r0 + numDefine4) >> 1] = r5;
      r0 = heapClassInst.heap32[r9 + numDefine19];
      r5 = ztv12btAxisSweep3;
      r5 = (r5 + numDefine8) | 0;
      heapClassInst.heap16[(r0 + numDefine6) >> 1] = r3;
      heapClassInst.heap32[r9] = r5;
      heapClassInst.heap32[r1 + numDefine13] = r7;
      heapClassInst.heap32[g0] = numDefine128;
      r0 = ztv35btSequentialImpulseConstraintSolver;
      znwj(i7);
      r7 = commonVariable.rg0 >> numDefine2;
      r0 = (r0 + numDefine8) | 0;
      heapClassInst.heap32[r7] = r0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine20] = r4;
      heapClassInst.heap32[r7 + numDefine4] = 0;
      heapClassInst.heap32[r7 + numDefine2] = 0;
      heapClassInst.heap32[r7 + numDefine3] = 0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine40] = r4;
      heapClassInst.heap32[r7 + numDefine9] = 0;
      heapClassInst.heap32[r7 + numDefine7] = 0;
      heapClassInst.heap32[r7 + numDefine8] = 0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine60] = r4;
      heapClassInst.heap32[r7 + numDefine14] = 0;
      heapClassInst.heap32[r7 + numDefine12] = 0;
      heapClassInst.heap32[r7 + numDefine13] = 0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine80] = r4;
      heapClassInst.heap32[r7 + numDefine19] = 0;
      heapClassInst.heap32[r7 + numDefine17] = 0;
      heapClassInst.heap32[r7 + numDefine18] = 0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine100] = r4;
      heapClassInst.heap32[r7 + numDefine24] = 0;
      heapClassInst.heap32[r7 + numDefine22] = 0;
      heapClassInst.heap32[r7 + numDefine23] = 0;
      heapClassInst.heap8[commonVariable.rg0 + numDefine120] = r4;
      heapClassInst.heap32[r7 + numDefine29] = 0;
      heapClassInst.heap32[r7 + numDefine27] = 0;
      heapClassInst.heap32[r7 + numDefine28] = 0;
      heapClassInst.heap32[r7 + numDefine31] = 0;
      heapClassInst.heap32[r1 + numDefine15] = commonVariable.rg0;
      heapClassInst.heap32[g0] = numDefine272;
      znwj(i7);
      r5 = commonVariable.rg0;
      r7 = heapClassInst.heap32[r1 + numDefine16];
      r8 = ztv16btCollisionWorld;
      r9 = heapClassInst.heap32[r1 + numDefine15];
      r10 = heapClassInst.heap32[r1 + numDefine13];
      r11 = heapClassInst.heap32[r1 + numDefine14];
      r8 = (r8 + numDefine8) | 0;
      r12 = r5 >> numDefine2;
      heapClassInst.heap32[r12] = r8;
      heapClassInst.heap8[r5 + numDefine20] = r4;
      heapClassInst.heap32[r12 + numDefine4] = 0;
      heapClassInst.heap32[r12 + numDefine2] = 0;
      heapClassInst.heap32[r12 + numDefine3] = 0;
      heapClassInst.heap32[r12 + numDefine6] = r11;
      heapClassInst.heap32[r12 + numDefine7] = 0;
      heapClassInst.heap32[r12 + numDefine8] = 0;
      heapClassInst.heap32[r12 + numDefine9] = 1;
      heapClassInst.heap32[r12 + numDefine10] = numDefine53216;
      heapClassInst.heap8[r5 + numDefine44] = r3;
      heapClassInst.heap32[r12 + numDefine12] = 0;
      heapClassInst.heap8[r5 + numDefine52] = r3;
      heapClassInst.heap8[r5 + numDefine53] = r4;
      heapClassInst.heap8[r5 + numDefine54] = r4;
      heapClassInst.heap32[r12 + numDefine14] = numDefine58986;
      heapClassInst.heap8[r5 + numDefine60] = r3;
      heapClassInst.heap32[r12 + numDefine16] = 0;
      heapClassInst.heap8[r5 + numDefine68] = r3;
      heapClassInst.heap32[r12 + numDefine18] = 0;
      heapClassInst.heap32[r12 + numDefine20] = r10;
      heapClassInst.heap32[r12 + numDefine21] = 0;
      r8 = r7 >> numDefine2;
      heapClassInst.heap8[r5 + numDefine88] = r4;
      r8 = heapClassInst.heap32[r8];
      r8 = r8 >> numDefine2;
      r8 = heapClassInst.heap32[r8 + numDefine4];
      heapClassInst.heap32[g0] = r7;
      functionTable[r8 >> numDefine2](i7);
      heapClassInst.heap32[r12 + numDefine19] = commonVariable.rg0;
      heapClassInst.heap32[r12 + numDefine18] = commonVariable.rg0;
      heapClassInst.heap32[r12 + numDefine23] = 0;
      heapClassInst.heap32[r12 + numDefine24] = 0;
      heapClassInst.heap32[r12 + numDefine25] = 0;
      heapClassInst.heap32[r12 + numDefine26] = numDefine42330;
      heapClassInst.heap32[r12 + numDefine27] = numDefine53216;
      heapClassInst.heap32[r12 + numDefine28] = numDefine53722;
      heapClassInst.heap32[r12 + numDefine30] = 0;
      heapClassInst.heap32[r12 + numDefine32] = numDefine04800;
      heapClassInst.heap32[r12 + numDefine31] = numDefine10;
      heapClassInst.heap32[r12 + numDefine34] = numDefine20557;
      heapClassInst.heap32[r12 + numDefine35] = numDefine31949;
      heapClassInst.heap32[r12 + numDefine36] = 0;
      heapClassInst.heap32[r12 + numDefine33] = numDefine53216;
      heapClassInst.heap32[r12 + numDefine37] = 0;
      heapClassInst.heap32[r12 + numDefine38] = numDefineNeg13270;
      heapClassInst.heap32[r12 + numDefine39] = 0;
      heapClassInst.heap32[r12 + numDefine40] = numDefine36634;
      heapClassInst.heap32[r12 + numDefine41] = numDefine260;
      r7 = ztv23btDiscreteDynamicsWorld;
      heapClassInst.heap32[r12 + numDefine42] = numDefine2;
      r7 = (r7 + numDefine8) | 0;
      heapClassInst.heap32[r12 + numDefine43] = numDefine128;
      heapClassInst.heap32[r12] = r7;
      heapClassInst.heap32[r12 + numDefine44] = r9;
      heapClassInst.heap8[r5 + numDefine200] = r4;
      heapClassInst.heap32[r12 + numDefine49] = 0;
      heapClassInst.heap32[r12 + numDefine47] = 0;
      heapClassInst.heap32[r12 + numDefine48] = 0;
      heapClassInst.heap8[r5 + numDefine220] = r4;
      heapClassInst.heap32[r12 + numDefine54] = 0;
      heapClassInst.heap32[r12 + numDefine52] = 0;
      heapClassInst.heap32[r12 + numDefine53] = 0;
      heapClassInst.heap32[r12 + numDefine56] = 0;
      heapClassInst.heap32[r12 + numDefine57] = numDefineNeg67456;
      heapClassInst.heap32[r12 + numDefine58] = 0;
      heapClassInst.heap32[r12 + numDefine59] = 0;
      heapClassInst.heap32[r12 + numDefine60] = 0;
      heapClassInst.heap8[r5 + numDefine246] = r3;
      heapClassInst.heap8[r5 + numDefine264] = r4;
      heapClassInst.heap32[r12 + numDefine65] = 0;
      heapClassInst.heap32[r12 + numDefine63] = 0;
      heapClassInst.heap32[r12 + numDefine64] = 0;
      heapClassInst.heap32[r12 + numDefine67] = 0;
      if (r9 !== 0) {
        heapClassInst.heap8[r5 + numDefine245] = r3;
        r7 = heapClassInst.heap32[r2];
      } else {
        r7 = heapClassInst.heap32[r2];
        r7 = (r7 + 1) | 0;
        heapClassInst.heap32[r2] = r7;
        heapClassInst.heap32[g0] = numDefine147;
        mallocNew(i7);
        r8 = commonVariable.rg0;
        if (r8 !== 0) {
          r9 = 0;
          r10 = (r8 + numDefine4) | 0;
          r9 = (r9 - r10) | 0;
          r9 = r9 & numDefine15;
          r9 = (r8 + r9) | 0;
          r10 = (r9 + numDefine4) | 0;
          r9 = r9 >> numDefine2;
          heapClassInst.heap32[r9] = r8;
          r8 = r10;
        }
        r9 = r8 >> numDefine2;
        heapClassInst.heap32[r9] = r0;
        heapClassInst.heap8[r8 + numDefine20] = r4;
        heapClassInst.heap32[r9 + numDefine4] = 0;
        heapClassInst.heap32[r9 + numDefine2] = 0;
        heapClassInst.heap32[r9 + numDefine3] = 0;
        heapClassInst.heap8[r8 + numDefine40] = r4;
        heapClassInst.heap32[r9 + numDefine9] = 0;
        heapClassInst.heap32[r9 + numDefine7] = 0;
        heapClassInst.heap32[r9 + numDefine8] = 0;
        heapClassInst.heap8[r8 + numDefine60] = r4;
        heapClassInst.heap32[r9 + numDefine14] = 0;
        heapClassInst.heap32[r9 + numDefine12] = 0;
        heapClassInst.heap32[r9 + numDefine13] = 0;
        heapClassInst.heap8[r8 + numDefine80] = r4;
        heapClassInst.heap32[r9 + numDefine19] = 0;
        heapClassInst.heap32[r9 + numDefine17] = 0;
        heapClassInst.heap32[r9 + numDefine18] = 0;
        heapClassInst.heap8[r8 + numDefine100] = r4;
        heapClassInst.heap32[r9 + numDefine24] = 0;
        heapClassInst.heap32[r9 + numDefine22] = 0;
        heapClassInst.heap32[r9 + numDefine23] = 0;
        heapClassInst.heap8[r8 + numDefine120] = r4;
        heapClassInst.heap32[r9 + numDefine29] = 0;
        heapClassInst.heap32[r9 + numDefine27] = 0;
        heapClassInst.heap32[r9 + numDefine28] = 0;
        r0 = r5 >> numDefine2;
        heapClassInst.heap32[r9 + numDefine31] = 0;
        heapClassInst.heap32[r0 + numDefine44] = r8;
        heapClassInst.heap8[r5 + numDefine245] = r4;
      }
      r0 = (r7 + 1) | 0;
      heapClassInst.heap32[r2] = r0;
      heapClassInst.heap32[g0] = numDefine87;
      mallocNew(i7);
      r0 = commonVariable.rg0;
      if (r0 !== 0) {
        r7 = (r0 + numDefine4) | 0;
        r7 = (r3 - r7) | 0;
        r7 = r7 & numDefine15;
        r7 = (r0 + r7) | 0;
        r8 = (r7 + numDefine4) | 0;
        r7 = r7 >> numDefine2;
        heapClassInst.heap32[r7] = r0;
        r0 = r8;
      }
      r7 = ztv25btSimulationIslandManager;
      r8 = r0 >> numDefine2;
      r7 = (r7 + numDefine8) | 0;
      heapClassInst.heap32[r8] = r7;
      heapClassInst.heap8[r0 + numDefine20] = r4;
      heapClassInst.heap32[r8 + numDefine4] = 0;
      heapClassInst.heap32[r8 + numDefine2] = 0;
      heapClassInst.heap32[r8 + numDefine3] = 0;
      heapClassInst.heap8[r0 + numDefine40] = r4;
      heapClassInst.heap32[r8 + numDefine9] = 0;
      heapClassInst.heap32[r8 + numDefine7] = 0;
      heapClassInst.heap32[r8 + numDefine8] = 0;
      heapClassInst.heap8[r0 + numDefine60] = r4;
      heapClassInst.heap32[r8 + numDefine14] = 0;
      heapClassInst.heap32[r8 + numDefine12] = 0;
      heapClassInst.heap32[r8 + numDefine13] = 0;
      r7 = r5 >> numDefine2;
      heapClassInst.heap8[r0 + numDefine64] = r4;
      heapClassInst.heap32[r7 + numDefine45] = r0;
      heapClassInst.heap8[r5 + numDefine244] = r4;
      heapClassInst.heap32[r1 + 1] = r5;
      r0 = heapClassInst.heap32[r7 + numDefine41];
      r0 = r0 | numDefine32;
      heapClassInst.heap32[r7 + numDefine41] = r0;
      heapClassInst.heap32[r7 + numDefine31] = numDefine5;
      heapClassInst.heap32[r1 + numDefine2] = 0;
      r0 = heapClassInst.heap32[r1 + 1];
      r5 = r0 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine17];
      r7 = sp + numDefineNeg41280;
      r8 = r7 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg10320] = 0;
      heapClassInst.heap32[r8 + 1] = numDefineNeg67456;
      heapClassInst.heap32[r8 + numDefine2] = 0;
      heapClassInst.heap32[r8 + numDefine3] = 0;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r7;
      functionTable[r5 >> numDefine2](i7);
      r0 = heapClassInst.heap32[r1 + numDefine17];
      if (r0 < numDefine5) {
        r0 = heapClassInst.heap32[r2];
        r5 = (r0 + 1) | 0;
        heapClassInst.heap32[r2] = r5;
        heapClassInst.heap32[g0] = numDefine71;
        mallocNew(i7);
        r5 = commonVariable.rg0;
        if (r5 !== 0) {
          r7 = 0;
          r8 = (r5 + numDefine4) | 0;
          r7 = (r7 - r8) | 0;
          r7 = r7 & numDefine15;
          r7 = (r5 + r7) | 0;
          r8 = (r7 + numDefine4) | 0;
          r7 = r7 >> numDefine2;
          heapClassInst.heap32[r7] = r5;
          r5 = r8;
        }
        r7 = r5 >> numDefine2;
        heapClassInst.heap32[r7 + numDefine2] = 0;
        heapClassInst.heap32[r7 + numDefine3] = numDefine53216;
        heapClassInst.heap32[r7 + numDefine4] = numDefine53216;
        heapClassInst.heap32[r7 + numDefine5] = numDefine53216;
        r8 = ztv10btBoxShape;
        heapClassInst.heap32[r7 + numDefine6] = 0;
        r8 = (r8 + numDefine8) | 0;
        heapClassInst.heap32[r7 + numDefine11] = numDefine58986;
        heapClassInst.heap32[r7] = r8;
        heapClassInst.heap32[r7 + 1] = 0;
        heapClassInst.heap32[r7 + numDefine7] = numDefine66243;
        heapClassInst.heap32[r7 + numDefine8] = numDefine04362;
        heapClassInst.heap32[r7 + numDefine9] = numDefine66243;
        heapClassInst.heap32[r7 + numDefine10] = 0;
        r7 = heapClassInst.heap32[r1 + numDefine5];
        r8 = heapClassInst.heap32[r1 + numDefine4];
        if (r7 === r8) {
          r9 = r8 << 1;
          r9 = r8 === 0 ? r4 : r9;
          if (!(r7 >= r9)) {
            if (r9 !== 0) {
              r7 = r9 << numDefine2;
              r0 = (r0 + numDefine2) | 0;
              r7 = r7 | numDefine3;
              heapClassInst.heap32[r2] = r0;
              r0 = (r7 + numDefine16) | 0;
              heapClassInst.heap32[g0] = r0;
              mallocNew(i7);
              r0 = commonVariable.rg0;
              if (r0 !== 0) {
                r7 = 0;
                r10 = (r0 + numDefine4) | 0;
                r7 = (r7 - r10) | 0;
                r7 = r7 & numDefine15;
                r7 = (r0 + r7) | 0;
                r10 = (r7 + numDefine4) | 0;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7] = r0;
                r0 = r10;
              }
            } else {
              r0 = 0;
            }
            repeat138: do {
              if (r8 < 1) {
                r10 = heapClassInst.heap32[r1 + numDefine6];
              } else {
                r7 = 0;
                while (true) {
                  r10 = heapClassInst.heap32[r1 + numDefine6];
                  r11 = r7 << numDefine2;
                  r12 = (r10 + r11) | 0;
                  r12 = r12 >> numDefine2;
                  r11 = (r0 + r11) | 0;
                  r12 = heapClassInst.heap32[r12];
                  r7 = (r7 + 1) | 0;
                  r11 = r11 >> numDefine2;
                  heapClassInst.heap32[r11] = r12;
                  if (!(r8 !== r7)) {
                    break repeat138;
                  }
                }
              }
            } while (false);
            if (r10 !== 0) {
              r7 = heapClassInst.heapU8[r6 + numDefine28];
              if (r7 !== 0) {
                r8 = gNumAlignedFree;
                r8 = r8 >> numDefine2;
                r7 = heapClassInst.heap32[r8];
                r7 = (r7 + 1) | 0;
                r10 = r10 >> numDefine2;
                heapClassInst.heap32[r8] = r7;
                r8 = heapClassInst.heap32[r10 + -1];
                heapClassInst.heap32[g0] = r8;
                free(i7);
                r8 = heapClassInst.heap32[r1 + numDefine4];
              }
              heapClassInst.heap32[r1 + numDefine6] = 0;
            }
            heapClassInst.heap8[r6 + numDefine28] = r4;
            heapClassInst.heap32[r1 + numDefine6] = r0;
            heapClassInst.heap32[r1 + numDefine5] = r9;
          }
        }
        r0 = r8 << numDefine2;
        r7 = heapClassInst.heap32[r1 + numDefine6];
        r0 = (r7 + r0) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = r5;
        r0 = heapClassInst.heap32[r1 + numDefine4];
        r0 = (r0 + 1) | 0;
        r7 = zgvzn11btTransform11getIdentityEvE17identityTransform;
        heapClassInst.heap32[r1 + numDefine4] = r0;
        r0 = heapClassInst.heapU8[r7];
        if (!(r0 !== 0)) {
          r0 = zgvzn11btMatrix3x311getIdentityEvE14identityMatrix;
          r8 = heapClassInst.heapU8[r0];
          if (!(r8 !== 0)) {
            r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
            r9 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
            r8 = r8 >> numDefine2;
            r10 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r8] = numDefine53216;
            r8 = r10 >> numDefine2;
            heapClassInst.heap32[r9] = numDefine53216;
            heapClassInst.heap32[r8] = numDefine53216;
            heapClassInst.heap8[r0] = r4;
          }
          r0 = zzn11btTransform11getIdentityEvE17identityTransform;
          r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
          r0 = r0 >> numDefine2;
          r8 = r8 >> numDefine2;
          heapClassInst.heap32[r0] = heapClassInst.heap32[r8];
          heapClassInst.heap32[r0 + 1] = 0;
          heapClassInst.heap32[r0 + numDefine2] = 0;
          r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
          heapClassInst.heap32[r0 + numDefine3] = 0;
          r8 = r8 >> numDefine2;
          heapClassInst.heap32[r0 + numDefine4] = 0;
          heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r8];
          heapClassInst.heap32[r0 + numDefine6] = 0;
          heapClassInst.heap32[r0 + numDefine7] = 0;
          r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
          heapClassInst.heap32[r0 + numDefine8] = 0;
          r8 = r8 >> numDefine2;
          heapClassInst.heap32[r0 + numDefine9] = 0;
          heapClassInst.heap32[r0 + numDefine10] = heapClassInst.heap32[r8];
          heapClassInst.heap32[r0 + numDefine11] = 0;
          heapClassInst.heap32[r0 + numDefine12] = 0;
          heapClassInst.heap32[r0 + numDefine13] = 0;
          heapClassInst.heap32[r0 + numDefine14] = 0;
          heapClassInst.heap32[r0 + numDefine15] = 0;
          heapClassInst.heap8[r7] = r4;
        }
        heapClassInst.heap32[g0] = numDefine200;
        r0 = ztv20btDefaultMotionState;
        znwj(i7);
        r8 = commonVariable.rg0 >> numDefine2;
        r0 = (r0 + numDefine8) | 0;
        heapClassInst.heap32[r8] = r0;
        heapClassInst.heap32[r8 + 1] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine2] = 0;
        heapClassInst.heap32[r8 + numDefine3] = 0;
        heapClassInst.heap32[r8 + numDefine4] = 0;
        heapClassInst.heap32[r8 + numDefine5] = 0;
        heapClassInst.heap32[r8 + numDefine6] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine7] = 0;
        heapClassInst.heap32[r8 + numDefine8] = 0;
        heapClassInst.heap32[r8 + numDefine9] = 0;
        heapClassInst.heap32[r8 + numDefine10] = 0;
        heapClassInst.heap32[r8 + numDefine11] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine12] = 0;
        heapClassInst.heap32[r8 + numDefine13] = 0;
        heapClassInst.heap32[r8 + numDefine14] = numDefineNeg68800;
        r0 = zzn11btTransform11getIdentityEvE17identityTransform;
        heapClassInst.heap32[r8 + numDefine15] = 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r8 + numDefine16] = 0;
        heapClassInst.heap32[r8 + numDefine17] = heapClassInst.heap32[r0];
        heapClassInst.heap32[r8 + numDefine18] = heapClassInst.heap32[r0 + 1];
        heapClassInst.heap32[r8 + numDefine19] = heapClassInst.heap32[r0 + numDefine2];
        heapClassInst.heap32[r8 + numDefine20] = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[r8 + numDefine21] = heapClassInst.heap32[r0 + numDefine4];
        heapClassInst.heap32[r8 + numDefine22] = heapClassInst.heap32[r0 + numDefine5];
        heapClassInst.heap32[r8 + numDefine23] = heapClassInst.heap32[r0 + numDefine6];
        heapClassInst.heap32[r8 + numDefine24] = heapClassInst.heap32[r0 + numDefine7];
        heapClassInst.heap32[r8 + numDefine25] = heapClassInst.heap32[r0 + numDefine8];
        heapClassInst.heap32[r8 + numDefine26] = heapClassInst.heap32[r0 + numDefine9];
        heapClassInst.heap32[r8 + numDefine27] = heapClassInst.heap32[r0 + numDefine10];
        heapClassInst.heap32[r8 + numDefine28] = heapClassInst.heap32[r0 + numDefine11];
        heapClassInst.heap32[r8 + numDefine29] = heapClassInst.heap32[r0 + numDefine12];
        heapClassInst.heap32[r8 + numDefine30] = heapClassInst.heap32[r0 + numDefine13];
        heapClassInst.heap32[r8 + numDefine31] = heapClassInst.heap32[r0 + numDefine14];
        heapClassInst.heap32[r8 + numDefine32] = heapClassInst.heap32[r0 + numDefine15];
        heapClassInst.heap32[r8 + numDefine33] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine34] = 0;
        heapClassInst.heap32[r8 + numDefine35] = 0;
        heapClassInst.heap32[r8 + numDefine36] = 0;
        heapClassInst.heap32[r8 + numDefine37] = 0;
        heapClassInst.heap32[r8 + numDefine38] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine39] = 0;
        heapClassInst.heap32[r8 + numDefine40] = 0;
        heapClassInst.heap32[r8 + numDefine41] = 0;
        heapClassInst.heap32[r8 + numDefine42] = 0;
        heapClassInst.heap32[r8 + numDefine43] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine44] = 0;
        heapClassInst.heap32[r8 + numDefine45] = 0;
        heapClassInst.heap32[r8 + numDefine46] = numDefineNeg68800;
        heapClassInst.heap32[r8 + numDefine47] = 0;
        heapClassInst.heap32[r8 + numDefine48] = 0;
        r0 = sp + numDefineNeg41416;
        heapClassInst.heap32[r8 + numDefine49] = 0;
        r8 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg10354] = 0;
        heapClassInst.heap32[r8 + 1] = commonVariable.rg0;
        heapClassInst.heap32[r8 + numDefine18] = r5;
        heapClassInst.heap32[r8 + numDefine19] = 0;
        heapClassInst.heap32[r8 + numDefine20] = 0;
        heapClassInst.heap32[r8 + numDefine21] = 0;
        heapClassInst.heap32[r8 + numDefine22] = 0;
        heapClassInst.heap32[r8 + numDefine23] = 0;
        heapClassInst.heap32[r8 + numDefine24] = 0;
        heapClassInst.heap32[r8 + numDefine25] = numDefine64608;
        heapClassInst.heap32[r8 + numDefine26] = 0;
        heapClassInst.heap32[r8 + numDefine27] = numDefine97773;
        r5 = 0;
        heapClassInst.heap32[r8 + numDefine28] = numDefine53216;
        heapClassInst.heap8[sp + numDefineNeg41300] = r5;
        heapClassInst.heap32[r8 + numDefine30] = numDefine93162;
        heapClassInst.heap32[r8 + numDefine31] = numDefine81770;
        heapClassInst.heap32[r8 + numDefine32] = numDefine81770;
        heapClassInst.heap32[r8 + numDefine33] = numDefine81770;
        heapClassInst.heap32[r8 + numDefine2] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine3] = 0;
        heapClassInst.heap32[r8 + numDefine4] = 0;
        heapClassInst.heap32[r8 + numDefine5] = 0;
        heapClassInst.heap32[r8 + numDefine6] = 0;
        heapClassInst.heap32[r8 + numDefine7] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine8] = 0;
        heapClassInst.heap32[r8 + numDefine9] = 0;
        heapClassInst.heap32[r8 + numDefine10] = 0;
        heapClassInst.heap32[r8 + numDefine11] = 0;
        heapClassInst.heap32[r8 + numDefine12] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine13] = 0;
        heapClassInst.heap32[r8 + numDefine14] = 0;
        heapClassInst.heap32[r8 + numDefine15] = 0;
        heapClassInst.heap32[r8 + numDefine16] = 0;
        heapClassInst.heap32[r8 + numDefine17] = 0;
        r7 = heapClassInst.heap32[r2];
        r7 = (r7 + 1) | 0;
        heapClassInst.heap32[r2] = r7;
        heapClassInst.heap32[g0] = numDefine627;
        mallocNew(i7);
        r7 = commonVariable.rg0;
        if (r7 !== 0) {
          r8 = (r7 + numDefine4) | 0;
          r5 = (r5 - r8) | 0;
          r5 = r5 & numDefine15;
          r5 = (r7 + r5) | 0;
          r8 = (r5 + numDefine4) | 0;
          r5 = r5 >> numDefine2;
          heapClassInst.heap32[r5] = r7;
          r7 = r8;
        }
        r5 = r7 >> numDefine2;
        heapClassInst.heap32[r5 + numDefine41] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine42] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine43] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine44] = 0;
        heapClassInst.heap32[r5 + numDefine45] = 0;
        heapClassInst.heap32[r5 + numDefine46] = numDefine44395;
        heapClassInst.heap32[r5 + numDefine47] = 0;
        heapClassInst.heap32[r5 + numDefine48] = 0;
        heapClassInst.heap32[r5 + numDefine49] = 0;
        heapClassInst.heap32[r5 + numDefine50] = 0;
        heapClassInst.heap32[r5 + numDefine51] = 1;
        heapClassInst.heap32[r5 + numDefine52] = -1;
        heapClassInst.heap32[r5 + numDefine53] = -1;
        heapClassInst.heap32[r5 + numDefine54] = 1;
        heapClassInst.heap32[r5 + numDefine55] = 0;
        heapClassInst.heap32[r5 + numDefine56] = numDefine64608;
        heapClassInst.heap32[r5 + numDefine57] = 0;
        heapClassInst.heap32[r5 + numDefine58] = 1;
        heapClassInst.heap32[r5 + numDefine59] = 0;
        heapClassInst.heap32[r5 + numDefine60] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine61] = 0;
        heapClassInst.heap32[r5 + numDefine62] = 0;
        heapClassInst.heap32[r5 + numDefine63] = 0;
        heapClassInst.heap32[r5 + 1] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        heapClassInst.heap32[r5 + numDefine4] = 0;
        heapClassInst.heap32[r5 + numDefine5] = 0;
        heapClassInst.heap32[r5 + numDefine6] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine7] = 0;
        heapClassInst.heap32[r5 + numDefine8] = 0;
        heapClassInst.heap32[r5 + numDefine9] = 0;
        heapClassInst.heap32[r5 + numDefine10] = 0;
        heapClassInst.heap32[r5 + numDefine11] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine12] = 0;
        heapClassInst.heap32[r5 + numDefine13] = 0;
        heapClassInst.heap32[r5 + numDefine14] = 0;
        r8 = ztv11btRigidBody;
        heapClassInst.heap32[r5 + numDefine15] = 0;
        r8 = (r8 + numDefine8) | 0;
        heapClassInst.heap32[r5 + numDefine16] = 0;
        heapClassInst.heap32[r5] = r8;
        heapClassInst.heap8[r7 + numDefine492] = r4;
        heapClassInst.heap32[r5 + numDefine122] = 0;
        heapClassInst.heap32[r5 + numDefine120] = 0;
        heapClassInst.heap32[r5 + numDefine121] = 0;
        heapClassInst.heap32[g0] = r7;
        heapClassInst.heap32[g0 + 1] = r0;
        zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
        r0 = heapClassInst.heap32[r1 + 1];
        r5 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine20];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r7;
        functionTable[r5 >> numDefine2](i7);
        r0 = heapClassInst.heap32[r1 + numDefine17];
      }
      repeat161: do {
        if (r0 > numDefine3) {
          if (r0 > numDefine5) {
            if (r0 === numDefine6) {
              zn13BenchmarkDemo11createTest6Ev(i7);
              return;
            } else {
              if (r0 === numDefine7) {
                zn13BenchmarkDemo11createTest6Ev(i7);
                r0 = sp + numDefineNeg41264;
                heapClassInst.heap32[g0] = numDefine8;
                r1 = r0 >> numDefine2;
                znwj(i7);
                heapClassInst.heap32[r1 + numDefine10006] = commonVariable.rg0;
                heapClassInst.heap32[g0] = commonVariable.rg0;
                heapClassInst.heap32[g0 + 1] = 0;
                getTimeOfDay(i7);
                heapClassInst.heap32[r1 + numDefine10000] = 0;
                heapClassInst.heap32[r1 + numDefine10001] = 0;
                heapClassInst.heap32[r1 + numDefine10005] = 0;
                heapClassInst.heap32[r1 + numDefine10004] = numDefine9999;
                heapClassInst.heap32[r1 + numDefine10003] = 0;
                heapClassInst.heap32[r1 + numDefine10002] = 0;
                heapClassInst.heap32[r1 + numDefine10007] = numDefine16192;
                heapClassInst.heap32[r1 + numDefine10008] = 0;
                heapClassInst.heap32[r1 + numDefine10009] = 0;
                heapClassInst.heap32[r1 + numDefine10010] = numDefine14848;
                heapClassInst.heap32[r1 + numDefine10011] = numDefine53216;
                f3 = 0;
                repeat169: while (true) {
                  f0 = r3;
                  f1 = numDefineFloat074;
                  f0 = f0 * f1;
                  f1 = numDefineFloat05;
                  f0 = f0 * f1;
                  heapClassInst.heapFloat[g0] = f0;
                  sinf(i7);
                  f2 = 1;
                  f1 = commonVariable.fg0 / f2;
                  f2 = f1 * f3;
                  heapClassInst.heapFloat[g0] = f0;
                  cosf(i7);
                  f4 = -f2;
                  f5 = commonVariable.fg0 * f3;
                  f6 = f2 * f3;
                  f7 = f4 - f2;
                  f8 = commonVariable.fg0 + f2;
                  f8 = f8 - f6;
                  f7 = f7 - f6;
                  f9 = f5 + f2;
                  f9 = f9 - f6;
                  f5 = f5 + f6;
                  f6 = f7 * f4;
                  f10 = f8 * commonVariable.fg0;
                  f5 = f5 - f1;
                  f11 = f9 * commonVariable.fg0;
                  f7 = f7 * f1;
                  f10 = f6 + f10;
                  f4 = f9 * f4;
                  r2 = r3 << numDefine4;
                  f0 = f5 * commonVariable.fg0;
                  f7 = f11 - f7;
                  f9 = f5 * f2;
                  f10 = f10 + f4;
                  f5 = f5 * f1;
                  r2 = (r0 + r2) | 0;
                  f0 = f6 + f0;
                  f1 = f8 * f1;
                  f6 = f7 - f9;
                  f2 = f8 * f2;
                  f5 = f10 + f5;
                  f7 = numDefine2500;
                  f0 = f0 - f1;
                  f1 = f6 + f2;
                  r2 = r2 >> numDefine2;
                  f2 = f5 * f7;
                  f0 = f0 - f4;
                  f1 = f1 * f7;
                  heapClassInst.heapFloat[r2 + numDefine4000] = f2;
                  f0 = f0 * f7;
                  heapClassInst.heapFloat[r2 + numDefine4001] = f1;
                  heapClassInst.heapFloat[r2 + numDefine4002] = f0;
                  heapClassInst.heap32[r2 + numDefine4003] = 0;
                  f1 = heapClassInst.heapFloat[r1 + numDefine10008];
                  heapClassInst.heapFloat[r2] = f1;
                  heapClassInst.heap32[r2 + 1] = numDefine14848;
                  heapClassInst.heap32[r2 + numDefine2] = 0;
                  f1 = f1 + f2;
                  heapClassInst.heap32[r2 + numDefine3] = 0;
                  f0 = f0 + f3;
                  heapClassInst.heapFloat[r2 + numDefine2000] = f1;
                  heapClassInst.heapFloat[r2 + numDefine2002] = f0;
                  heapClassInst.heap32[r2 + numDefine2003] = 0;
                  heapClassInst.heap32[r2 + numDefine2001] = numDefineNeg37568;
                  heapClassInst.heap32[r2 + numDefine8000] = numDefine53216;
                  heapClassInst.heap32[r2 + numDefine8001] = 0;
                  r3 = (r3 + 1) | 0;
                  heapClassInst.heap32[r2 + numDefine8002] = 0;
                  heapClassInst.heap32[r2 + numDefine8003] = 0;
                  if (!(r3 !== numDefine500)) {
                    break repeat169;
                  }
                }
                r2 = zl10raycastBar;
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                memcpy(i7);
                r3 = (r2 + numDefine8000) | 0;
                r4 = (r0 + numDefine8000) | 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                memcpy(i7);
                r3 = (r2 + numDefine16000) | 0;
                r4 = (r0 + numDefine16000) | 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                memcpy(i7);
                r3 = (r2 + numDefine24000) | 0;
                r4 = (r0 + numDefine24000) | 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                memcpy(i7);
                r3 = (r2 + numDefine32000) | 0;
                r0 = (r0 + numDefine32000) | 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                memcpy(i7);
                r0 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r1 + numDefine10000];
                heapClassInst.heap32[r0 + numDefine10000] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10001];
                heapClassInst.heap32[r0 + numDefine10001] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10002];
                heapClassInst.heap32[r0 + numDefine10002] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10003];
                heapClassInst.heap32[r0 + numDefine10003] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10004];
                heapClassInst.heap32[r0 + numDefine10004] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10005];
                heapClassInst.heap32[r0 + numDefine10005] = r2;
                r2 = heapClassInst.heap32[r1 + numDefine10006];
                r2 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r0 + numDefine10006];
                r4 = heapClassInst.heap32[r2 + 1];
                r2 = heapClassInst.heap32[r2];
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r3] = r2;
                heapClassInst.heap32[r3 + 1] = r4;
                heapClassInst.heap32[r0 + numDefine10007] = heapClassInst.heap32[r1 + numDefine10007];
                heapClassInst.heap32[r0 + numDefine10008] = heapClassInst.heap32[r1 + numDefine10008];
                heapClassInst.heap32[r0 + numDefine10009] = heapClassInst.heap32[r1 + numDefine10009];
                heapClassInst.heap32[r0 + numDefine10010] = heapClassInst.heap32[r1 + numDefine10010];
                heapClassInst.heap32[r0 + numDefine10011] = heapClassInst.heap32[r1 + numDefine10011];
                r0 = heapClassInst.heap32[r1 + numDefine10006];
                heapClassInst.heap32[g0] = r0;
                zdlPv(i7);
                return;
              } else {
                break repeat161;
              }
            }
          } else {
            if (r0 === numDefine4) {
              r3 = heapClassInst.heap32[r2];
              r3 = (r3 + 1) | 0;
              heapClassInst.heap32[r2] = r3;
              heapClassInst.heap32[g0] = numDefine127;
              mallocNew(i7);
              r2 = commonVariable.rg0;
              if (r2 !== 0) {
                r3 = 0;
                r4 = (r2 + numDefine4) | 0;
                r3 = (r3 - r4) | 0;
                r3 = r3 & numDefine15;
                r3 = (r2 + r3) | 0;
                r4 = (r3 + numDefine4) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r3] = r2;
                r2 = r4;
              }
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = 0;
              heapClassInst.heap32[g0 + numDefine2] = 0;
              r3 = r2 >> numDefine2;
              zn17btConvexHullShapeC1EPKfii(i7);
              r4 = heapClassInst.heap32[r3];
              r4 = r4 >> numDefine2;
              r4 = heapClassInst.heap32[r4 + numDefine6];
              r0 = sp + numDefineNeg96;
              r5 = r0 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg24] = numDefine53216;
              heapClassInst.heap32[r5 + 1] = numDefine53216;
              heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
              heapClassInst.heap32[r5 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = r0;
              r0 = 0;
              functionTable[r4 >> numDefine2](i7);
              repeat178: while (true) {
                r4 = (r0 * numDefineNeg3) | 0;
                r5 = zl7TaruVtx;
                r4 = r4 << numDefine2;
                r4 = (r5 + r4) | 0;
                r5 = sp + numDefineNeg80;
                r4 = r4 >> numDefine2;
                r7 = r5 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg20] = heapClassInst.heap32[r4];
                heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r4 + 1];
                heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                heapClassInst.heap32[r7 + numDefine3] = 0;
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r5;
                r0 = (r0 + -1) | 0;
                zn17btConvexHullShape8addPointERK9btVector3(i7);
                if (r0 === numDefineNeg43) {
                  break repeat178;
                }
              }
              r4 = sp + numDefineNeg160;
              r0 = r4 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg40] = numDefine53216;
              heapClassInst.heap32[r0 + 1] = 0;
              heapClassInst.heap32[r0 + numDefine2] = 0;
              heapClassInst.heap32[r0 + numDefine3] = 0;
              heapClassInst.heap32[r0 + numDefine4] = 0;
              heapClassInst.heap32[r0 + numDefine5] = numDefine53216;
              heapClassInst.heap32[r0 + numDefine6] = 0;
              heapClassInst.heap32[r0 + numDefine7] = 0;
              heapClassInst.heap32[r0 + numDefine8] = 0;
              heapClassInst.heap32[r0 + numDefine9] = 0;
              heapClassInst.heap32[r0 + numDefine10] = numDefine53216;
              heapClassInst.heap32[r0 + numDefine11] = 0;
              heapClassInst.heap32[r0 + numDefine12] = 0;
              heapClassInst.heap32[r0 + numDefine13] = 0;
              heapClassInst.heap32[r0 + numDefine14] = 0;
              r5 = sp + numDefineNeg176;
              heapClassInst.heap32[r0 + numDefine15] = 0;
              r7 = r5 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg44] = 0;
              heapClassInst.heap32[r7 + 1] = 0;
              heapClassInst.heap32[r7 + numDefine2] = 0;
              heapClassInst.heap32[r7 + numDefine3] = 0;
              r3 = heapClassInst.heap32[r3];
              r3 = r3 >> numDefine2;
              r7 = heapClassInst.heap32[r3 + numDefine8];
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = numDefine53216;
              heapClassInst.heap32[g0 + numDefine2] = r5;
              r3 = numDefine15;
              f0 = numDefine3;
              f2 = numDefineNeg18;
              f3 = numDefineFloat15;
              functionTable[r7 >> numDefine2](i7);
              f1 = f0;
              repeat181: while (true) {
                f4 = f3 + f0;
                r5 = 0;
                r7 = r5;
                repeat183: while (true) {
                  f5 = r7;
                  f5 = f5 * f4;
                  f5 = f5 + f2;
                  r8 = r5;
                  repeat185: while (true) {
                    f6 = r8;
                    f6 = f6 * f4;
                    f6 = f6 + f2;
                    heapClassInst.heapFloat[r0 + numDefine12] = f6;
                    heapClassInst.heapFloat[r0 + numDefine13] = f1;
                    heapClassInst.heapFloat[r0 + numDefine14] = f5;
                    heapClassInst.heap32[r0 + numDefine15] = 0;
                    r9 = heapClassInst.heap32[r1];
                    r9 = r9 >> numDefine2;
                    r9 = heapClassInst.heap32[r9 + numDefine2];
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = numDefine53216;
                    heapClassInst.heap32[g0 + numDefine2] = r4;
                    heapClassInst.heap32[g0 + numDefine3] = r2;
                    r8 = (r8 + 1) | 0;
                    functionTable[r9 >> numDefine2](i7);
                    if (!(r8 !== numDefine8)) {
                      break repeat185;
                    }
                  }
                  r7 = (r7 + 1) | 0;
                  if (!(r7 !== numDefine8)) {
                    break repeat183;
                  }
                }
                f4 = numDefineFloat068;
                f5 = numDefineNegFloat006;
                f4 = f3 * f4;
                f6 = numDefine3;
                f3 = f3 * f5;
                f5 = numDefine7;
                f6 = f4 + f6;
                f3 = f3 * f5;
                r3 = (r3 + -1) | 0;
                f1 = f1 + f6;
                f2 = f3 + f2;
                f3 = f4;
                if (r3 === 0) {
                  break repeat161;
                } else {
                  continue repeat181;
                }
              }
            } else {
              if (r0 === numDefine5) {
                r3 = numDefine10;
                f0 = numDefine20;
                f1 = numDefine2;
                f2 = numDefineNeg25;
                repeat191: while (true) {
                  f3 = numDefine3;
                  f4 = numDefine25;
                  f5 = f1 + f3;
                  f4 = f0 + f4;
                  r0 = 0;
                  r5 = r0;
                  repeat193: while (true) {
                    f6 = r5;
                    f6 = f6 * f5;
                    f6 = f6 + f2;
                    f7 = numDefine5;
                    f6 = f6 * f7;
                    f8 = 0;
                    f6 = f6 + f8;
                    r7 = r0;
                    repeat195: while (true) {
                      r8 = zl8nextRand;
                      r8 = r8 >> numDefine2;
                      r9 = heapClassInst.heap32[r8];
                      r9 = (r9 * numDefine14013) | 0;
                      r9 = (r9 + numDefine31011) | 0;
                      r10 = sp + numDefineNeg64;
                      heapClassInst.heap32[r8] = r9;
                      r8 = r10 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
                      heapClassInst.heap32[r8 + 1] = 0;
                      heapClassInst.heap32[r8 + numDefine2] = 0;
                      heapClassInst.heap32[r8 + numDefine3] = 0;
                      heapClassInst.heap32[r8 + numDefine4] = 0;
                      heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                      heapClassInst.heap32[r8 + numDefine6] = 0;
                      heapClassInst.heap32[r8 + numDefine7] = 0;
                      f9 = r7;
                      heapClassInst.heap32[r8 + numDefine8] = 0;
                      f9 = f9 * f5;
                      heapClassInst.heap32[r8 + numDefine9] = 0;
                      f9 = f9 + f2;
                      heapClassInst.heap32[r8 + numDefine10] = numDefine53216;
                      f9 = f9 * f7;
                      f9 = f9 + f8;
                      heapClassInst.heap32[r8 + numDefine11] = 0;
                      r9 = r9 >>> numDefine16;
                      heapClassInst.heapFloat[r8 + numDefine12] = f9;
                      r9 = r9 & numDefine32767;
                      heapClassInst.heapFloat[r8 + numDefine13] = f4;
                      r9 = Math.floor(uint(r9) % uint(numDefine9));
                      heapClassInst.heapFloat[r8 + numDefine14] = f6;
                      heapClassInst.heap32[r8 + numDefine15] = 0;
                      if (!(uint(r9) > uint(numDefine8))) {
                        r8 = r4 << r9;
                        r11 = r8 & numDefine7;
                        if (r11 !== 0) {
                          r8 = heapClassInst.heap32[r2];
                          r8 = (r8 + 1) | 0;
                          heapClassInst.heap32[r2] = r8;
                          r9 = (r9 + 1) | 0;
                          f9 = r9;
                          f10 = numDefineFloat05;
                          heapClassInst.heap32[g0] = numDefine71;
                          f9 = f9 * f10;
                          f10 = numDefineFloat15;
                          mallocNew(i7);
                          r9 = commonVariable.rg0;
                          f10 = f9 * f10;
                          if (r9 !== 0) {
                            r8 = 0;
                            r11 = (r9 + numDefine4) | 0;
                            r8 = (r8 - r11) | 0;
                            r8 = r8 & numDefine15;
                            r8 = (r9 + r8) | 0;
                            r11 = (r8 + numDefine4) | 0;
                            r8 = r8 >> numDefine2;
                            heapClassInst.heap32[r8] = r9;
                            r9 = r11;
                          }
                          r8 = r9 >> numDefine2;
                          heapClassInst.heap32[r8 + numDefine2] = 0;
                          heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
                          heapClassInst.heap32[r8 + numDefine4] = numDefine53216;
                          heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                          r11 = ztv10btBoxShape;
                          heapClassInst.heap32[r8 + numDefine6] = 0;
                          r11 = (r11 + numDefine8) | 0;
                          heapClassInst.heap32[r8 + numDefine11] = numDefine58986;
                          heapClassInst.heap32[r8] = r11;
                          f11 = numDefineNegFloat028;
                          f10 = f10 + f11;
                          heapClassInst.heap32[r8 + 1] = 0;
                          heapClassInst.heapFloat[r8 + numDefine7] = f10;
                          heapClassInst.heapFloat[r8 + numDefine8] = f10;
                          heapClassInst.heapFloat[r8 + numDefine9] = f10;
                          heapClassInst.heap32[r8 + numDefine10] = 0;
                          r8 = heapClassInst.heap32[r1];
                          r8 = r8 >> numDefine2;
                          r8 = heapClassInst.heap32[r8 + numDefine2];
                          heapClassInst.heap32[g0] = r6;
                          heapClassInst.heapFloat[g0 + 1] = f9;
                          heapClassInst.heap32[g0 + numDefine2] = r10;
                          heapClassInst.heap32[g0 + numDefine3] = r9;
                          functionTable[r8 >> numDefine2](i7);
                        } else {
                          r11 = r8 & numDefine56;
                          if (r11 !== 0) {
                            r8 = heapClassInst.heap32[r2];
                            r8 = (r8 + 1) | 0;
                            heapClassInst.heap32[r2] = r8;
                            r9 = (r9 + numDefineNeg2) | 0;
                            heapClassInst.heap32[g0] = numDefine71;
                            f9 = r9;
                            f10 = numDefineFloat05;
                            mallocNew(i7);
                            r9 = commonVariable.rg0;
                            f9 = f9 * f10;
                            if (r9 !== 0) {
                              r8 = 0;
                              r11 = (r9 + numDefine4) | 0;
                              r8 = (r8 - r11) | 0;
                              r8 = r8 & numDefine15;
                              r8 = (r9 + r8) | 0;
                              r11 = (r8 + numDefine4) | 0;
                              r8 = r8 >> numDefine2;
                              heapClassInst.heap32[r8] = r9;
                              r9 = r11;
                            }
                            r8 = r9 >> numDefine2;
                            heapClassInst.heap32[r8 + numDefine2] = 0;
                            heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
                            heapClassInst.heap32[r8 + numDefine4] = numDefine53216;
                            r11 = ztv13btSphereShape;
                            heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                            r11 = (r11 + numDefine8) | 0;
                            heapClassInst.heap32[r8 + numDefine6] = 0;
                            heapClassInst.heap32[r8] = r11;
                            f10 = numDefineFloat15;
                            f10 = f9 * f10;
                            heapClassInst.heap32[r8 + 1] = numDefine8;
                            heapClassInst.heapFloat[r8 + numDefine7] = f10;
                            heapClassInst.heapFloat[r8 + numDefine11] = f10;
                            r8 = heapClassInst.heap32[r1];
                            r8 = r8 >> numDefine2;
                            r8 = heapClassInst.heap32[r8 + numDefine2];
                            heapClassInst.heap32[g0] = r6;
                            heapClassInst.heapFloat[g0 + 1] = f9;
                            heapClassInst.heap32[g0 + numDefine2] = r10;
                            heapClassInst.heap32[g0 + numDefine3] = r9;
                            functionTable[r8 >> numDefine2](i7);
                          } else {
                            r8 = r8 & numDefine448;
                            if (r8 !== 0) {
                              r8 = heapClassInst.heap32[r2];
                              r8 = (r8 + 1) | 0;
                              heapClassInst.heap32[r2] = r8;
                              r8 = (r9 + numDefineNeg5) | 0;
                              heapClassInst.heap32[g0] = numDefine75;
                              f9 = r8;
                              f10 = numDefineFloat05;
                              mallocNew(i7);
                              r8 = commonVariable.rg0;
                              f9 = f9 * f10;
                              if (r8 !== 0) {
                                r9 = 0;
                                r11 = (r8 + numDefine4) | 0;
                                r9 = (r9 - r11) | 0;
                                r9 = r9 & numDefine15;
                                r9 = (r8 + r9) | 0;
                                r11 = (r9 + numDefine4) | 0;
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r9] = r8;
                                r8 = r11;
                              }
                              r9 = r8 >> numDefine2;
                              heapClassInst.heap32[r9 + numDefine2] = 0;
                              heapClassInst.heap32[r9 + numDefine3] = numDefine53216;
                              heapClassInst.heap32[r9 + numDefine4] = numDefine53216;
                              heapClassInst.heap32[r9 + numDefine5] = numDefine53216;
                              r11 = ztv14btCapsuleShape;
                              heapClassInst.heap32[r9 + numDefine6] = 0;
                              r11 = (r11 + numDefine8) | 0;
                              heapClassInst.heap32[r9 + numDefine11] = numDefine58986;
                              heapClassInst.heap32[r9] = r11;
                              heapClassInst.heap32[r9 + 1] = numDefine10;
                              heapClassInst.heap32[r9 + numDefine13] = 1;
                              f11 = f9 + f9;
                              f10 = f11 * f10;
                              heapClassInst.heapFloat[r9 + numDefine7] = f9;
                              heapClassInst.heapFloat[r9 + numDefine8] = f10;
                              heapClassInst.heapFloat[r9 + numDefine9] = f9;
                              heapClassInst.heap32[r9 + numDefine10] = 0;
                              r9 = heapClassInst.heap32[r1];
                              r9 = r9 >> numDefine2;
                              r9 = heapClassInst.heap32[r9 + numDefine2];
                              heapClassInst.heap32[g0] = r6;
                              heapClassInst.heapFloat[g0 + 1] = f9;
                              heapClassInst.heap32[g0 + numDefine2] = r10;
                              heapClassInst.heap32[g0 + numDefine3] = r8;
                              functionTable[r9 >> numDefine2](i7);
                            }
                          }
                        }
                      }
                      r7 = (r7 + 1) | 0;
                      if (!(r7 !== numDefine10)) {
                        break repeat195;
                      }
                    }
                    r5 = (r5 + 1) | 0;
                    if (!(r5 !== numDefine10)) {
                      break repeat193;
                    }
                  }
                  f4 = numDefineFloat179;
                  f5 = numDefineNegFloat006;
                  f4 = f1 * f4;
                  f1 = f1 * f5;
                  f5 = numDefine9;
                  f3 = f4 + f3;
                  f1 = f1 * f5;
                  r3 = (r3 + -1) | 0;
                  f0 = f0 + f3;
                  f2 = f1 + f2;
                  f1 = f4;
                  if (!(r3 !== 0)) {
                    break repeat191;
                  }
                }
                zn13BenchmarkDemo19createLargeMeshBodyEv(i7);
                return;
              } else {
                break repeat161;
              }
            }
          }
        } else {
          if (r0 === 1) {
            r3 = heapClassInst.heap32[r2];
            r3 = (r3 + 1) | 0;
            heapClassInst.heap32[r2] = r3;
            heapClassInst.heap32[g0] = numDefine71;
            mallocNew(i7);
            r2 = commonVariable.rg0;
            if (r2 !== 0) {
              r3 = 0;
              r4 = (r2 + numDefine4) | 0;
              r3 = (r3 - r4) | 0;
              r3 = r3 & numDefine15;
              r3 = (r2 + r3) | 0;
              r4 = (r3 + numDefine4) | 0;
              r3 = r3 >> numDefine2;
              heapClassInst.heap32[r3] = r2;
              r2 = r4;
            }
            r3 = r2 >> numDefine2;
            heapClassInst.heap32[r3 + numDefine2] = 0;
            heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
            heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
            heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
            r4 = ztv10btBoxShape;
            heapClassInst.heap32[r3 + numDefine6] = 0;
            r4 = (r4 + numDefine8) | 0;
            heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
            heapClassInst.heap32[r3] = r4;
            heapClassInst.heap32[r3 + 1] = 0;
            heapClassInst.heap32[r3 + numDefine7] = numDefine82127;
            heapClassInst.heap32[r3 + numDefine8] = numDefine82127;
            heapClassInst.heap32[r3 + numDefine9] = numDefine82127;
            r4 = sp + numDefineNeg1152;
            heapClassInst.heap32[r3 + numDefine10] = 0;
            r3 = r4 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg288] = 0;
            heapClassInst.heap32[r3 + 1] = 0;
            heapClassInst.heap32[r3 + numDefine2] = 0;
            heapClassInst.heap32[r3 + numDefine3] = 0;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = numDefine41824;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
            r3 = sp + numDefineNeg1216;
            r4 = r3 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg304] = numDefine53216;
            heapClassInst.heap32[r4 + 1] = 0;
            heapClassInst.heap32[r4 + numDefine2] = 0;
            heapClassInst.heap32[r4 + numDefine3] = 0;
            heapClassInst.heap32[r4 + numDefine4] = 0;
            heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
            heapClassInst.heap32[r4 + numDefine6] = 0;
            heapClassInst.heap32[r4 + numDefine7] = 0;
            heapClassInst.heap32[r4 + numDefine8] = 0;
            heapClassInst.heap32[r4 + numDefine9] = 0;
            heapClassInst.heap32[r4 + numDefine10] = numDefine53216;
            heapClassInst.heap32[r4 + numDefine11] = 0;
            heapClassInst.heap32[r4 + numDefine12] = 0;
            heapClassInst.heap32[r4 + numDefine13] = 0;
            r0 = numDefine47;
            f0 = numDefineNeg12;
            f1 = numDefine2;
            heapClassInst.heap32[r4 + numDefine14] = 0;
            heapClassInst.heap32[r4 + numDefine15] = 0;
            repeat225: while (true) {
              r5 = 0;
              r7 = r5;
              repeat227: while (true) {
                f2 = r7;
                f3 = numDefine3;
                f2 = f2 * f3;
                f2 = f2 + f0;
                r8 = r5;
                repeat229: while (true) {
                  f4 = r8;
                  f4 = f4 * f3;
                  f4 = f4 + f0;
                  heapClassInst.heapFloat[r4 + numDefine12] = f4;
                  heapClassInst.heapFloat[r4 + numDefine13] = f1;
                  heapClassInst.heapFloat[r4 + numDefine14] = f2;
                  heapClassInst.heap32[r4 + numDefine15] = 0;
                  r9 = heapClassInst.heap32[r1];
                  r9 = r9 >> numDefine2;
                  r9 = heapClassInst.heap32[r9 + numDefine2];
                  heapClassInst.heap32[g0] = r6;
                  heapClassInst.heap32[g0 + 1] = numDefine41824;
                  heapClassInst.heap32[g0 + numDefine2] = r3;
                  heapClassInst.heap32[g0 + numDefine3] = r2;
                  r8 = (r8 + 1) | 0;
                  functionTable[r9 >> numDefine2](i7);
                  if (!(r8 !== numDefine8)) {
                    break repeat229;
                  }
                }
                r7 = (r7 + 1) | 0;
                if (!(r7 !== numDefine8)) {
                  break repeat227;
                }
              }
              f2 = numDefineNegFloat352;
              r0 = (r0 + -1) | 0;
              f1 = f1 + f3;
              f0 = f0 + f2;
              if (r0 === 0) {
                break repeat161;
              } else {
                continue repeat225;
              }
            }
          } else {
            if (r0 === numDefine2) {
              r3 = heapClassInst.heap32[r2];
              r3 = (r3 + 1) | 0;
              heapClassInst.heap32[r2] = r3;
              heapClassInst.heap32[g0] = numDefine71;
              mallocNew(i7);
              r3 = commonVariable.rg0;
              if (r3 !== 0) {
                r4 = 0;
                r0 = (r3 + numDefine4) | 0;
                r4 = (r4 - r0) | 0;
                r4 = r4 & numDefine15;
                r4 = (r3 + r4) | 0;
                r0 = (r4 + numDefine4) | 0;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = r3;
                r3 = r0;
              }
              r4 = r3 >> numDefine2;
              heapClassInst.heap32[r4 + numDefine2] = 0;
              heapClassInst.heap32[r4 + numDefine3] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine4] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
              r0 = ztv10btBoxShape;
              heapClassInst.heap32[r4 + numDefine6] = 0;
              r0 = (r0 + numDefine8) | 0;
              heapClassInst.heap32[r4 + numDefine11] = numDefine58986;
              heapClassInst.heap32[r4] = r0;
              heapClassInst.heap32[r4 + 1] = 0;
              heapClassInst.heap32[r4 + numDefine7] = numDefine82127;
              heapClassInst.heap32[r4 + numDefine8] = numDefine82127;
              heapClassInst.heap32[r4 + numDefine9] = numDefine82127;
              r5 = sp + numDefineNeg1024;
              heapClassInst.heap32[r4 + numDefine10] = 0;
              r4 = r5 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg256] = numDefine53216;
              heapClassInst.heap32[r4 + 1] = 0;
              heapClassInst.heap32[r4 + numDefine2] = 0;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              heapClassInst.heap32[r4 + numDefine4] = 0;
              heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine6] = 0;
              heapClassInst.heap32[r4 + numDefine7] = 0;
              heapClassInst.heap32[r4 + numDefine8] = 0;
              heapClassInst.heap32[r4 + numDefine9] = 0;
              heapClassInst.heap32[r4 + numDefine10] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine11] = 0;
              heapClassInst.heap32[r4 + numDefine12] = 0;
              heapClassInst.heap32[r4 + numDefine13] = 0;
              heapClassInst.heap32[r4 + numDefine14] = 0;
              r7 = sp + numDefineNeg1040;
              heapClassInst.heap32[r4 + numDefine15] = 0;
              r8 = r7 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg260] = 0;
              heapClassInst.heap32[r8 + 1] = 0;
              heapClassInst.heap32[r8 + numDefine2] = 0;
              heapClassInst.heap32[r8 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r3;
              heapClassInst.heap32[g0 + 1] = numDefine53216;
              heapClassInst.heap32[g0 + numDefine2] = r7;
              r7 = numDefine12;
              f0 = numDefineNegFloat267;
              f1 = 1;
              znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
              f2 = f0;
              f8 = numDefineNeg20;
              repeat239: while (true) {
                if (!(r7 < 1)) {
                  f4 = 0;
                  f3 = f1 + f4;
                  r8 = 0;
                  r9 = r8;
                  repeat243: while (true) {
                    f5 = r9;
                    f6 = numDefineFloat009;
                    f5 = f5 * f6;
                    f5 = f5 + f0;
                    f5 = f5 + f4;
                    r10 = r8;
                    repeat245: while (true) {
                      f7 = r10;
                      f7 = f7 * f6;
                      f7 = f7 + f2;
                      f7 = f7 + f8;
                      heapClassInst.heapFloat[r4 + numDefine12] = f7;
                      heapClassInst.heapFloat[r4 + numDefine13] = f3;
                      heapClassInst.heapFloat[r4 + numDefine14] = f5;
                      heapClassInst.heap32[r4 + numDefine15] = 0;
                      r11 = heapClassInst.heap32[r1];
                      r11 = r11 >> numDefine2;
                      r11 = heapClassInst.heap32[r11 + numDefine2];
                      heapClassInst.heap32[g0] = r6;
                      heapClassInst.heap32[g0 + 1] = numDefine53216;
                      heapClassInst.heap32[g0 + numDefine2] = r5;
                      heapClassInst.heap32[g0 + numDefine3] = r3;
                      r10 = (r10 + 1) | 0;
                      functionTable[r11 >> numDefine2](i7);
                      if (!(r7 !== r10)) {
                        break repeat245;
                      }
                    }
                    r9 = (r9 + 1) | 0;
                    if (!(r7 !== r9)) {
                      break repeat243;
                    }
                  }
                }
                f3 = numDefineFloat009;
                f4 = numDefineFloat037;
                r7 = (r7 + -1) | 0;
                f1 = f1 + f3;
                f0 = f0 + f4;
                f2 = f2 + f4;
                if (r7 === 0) {
                  break repeat239;
                }
              }
              r3 = sp + numDefineNeg1136;
              r4 = r3 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg284] = numDefine53216;
              heapClassInst.heap32[r4 + 1] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
              r5 = sp + numDefineNeg1120;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              r4 = r5 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg280] = numDefineNeg41824;
              heapClassInst.heap32[r4 + 1] = 0;
              heapClassInst.heap32[r4 + numDefine2] = 0;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r5;
              heapClassInst.heap32[g0 + 1] = r3;
              r3 = sp + numDefineNeg1104;
              zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
              r4 = r3 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg276] = numDefine53216;
              heapClassInst.heap32[r4 + 1] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
              r5 = sp + numDefineNeg1088;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              r4 = r5 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg272] = numDefine30432;
              heapClassInst.heap32[r4 + 1] = 0;
              heapClassInst.heap32[r4 + numDefine2] = 0;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r5;
              heapClassInst.heap32[g0 + 1] = r3;
              r3 = sp + numDefineNeg1072;
              zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
              r4 = r3 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg268] = numDefine53216;
              heapClassInst.heap32[r4 + 1] = numDefine53216;
              heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
              r5 = sp + numDefineNeg1056;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              r4 = r5 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg264] = numDefine16192;
              heapClassInst.heap32[r4 + 1] = 0;
              heapClassInst.heap32[r4 + numDefine2] = 0;
              heapClassInst.heap32[r4 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r5;
              heapClassInst.heap32[g0 + 1] = r3;
              zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
              r3 = heapClassInst.heap32[r2];
              r3 = (r3 + 1) | 0;
              heapClassInst.heap32[r2] = r3;
              heapClassInst.heap32[g0] = numDefine71;
              mallocNew(i7);
              r2 = commonVariable.rg0;
              if (r2 !== 0) {
                r3 = 0;
                r4 = (r2 + numDefine4) | 0;
                r3 = (r3 - r4) | 0;
                r3 = r3 & numDefine15;
                r3 = (r2 + r3) | 0;
                r4 = (r3 + numDefine4) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r3] = r2;
                r2 = r4;
              }
              r3 = r2 >> numDefine2;
              heapClassInst.heap32[r3 + numDefine2] = 0;
              heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
              heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
              heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
              heapClassInst.heap32[r3 + numDefine6] = 0;
              heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
              heapClassInst.heap32[r3] = r0;
              heapClassInst.heap32[r3 + 1] = 0;
              heapClassInst.heap32[r3 + numDefine7] = numDefine82127;
              heapClassInst.heap32[r3 + numDefine8] = numDefine82127;
              heapClassInst.heap32[r3 + numDefine9] = numDefine82127;
              r4 = sp + numDefineNeg944;
              heapClassInst.heap32[r3 + numDefine10] = 0;
              r3 = r4 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg236] = numDefine53216;
              heapClassInst.heap32[r3 + 1] = 0;
              heapClassInst.heap32[r3 + numDefine2] = 0;
              heapClassInst.heap32[r3 + numDefine3] = 0;
              heapClassInst.heap32[r3 + numDefine4] = 0;
              heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
              heapClassInst.heap32[r3 + numDefine6] = 0;
              heapClassInst.heap32[r3 + numDefine7] = 0;
              heapClassInst.heap32[r3 + numDefine8] = 0;
              heapClassInst.heap32[r3 + numDefine9] = 0;
              heapClassInst.heap32[r3 + numDefine10] = numDefine53216;
              heapClassInst.heap32[r3 + numDefine11] = 0;
              heapClassInst.heap32[r3 + numDefine12] = 0;
              heapClassInst.heap32[r3 + numDefine13] = 0;
              heapClassInst.heap32[r3 + numDefine14] = 0;
              r0 = sp + numDefineNeg960;
              heapClassInst.heap32[r3 + numDefine15] = 0;
              r5 = r0 >> numDefine2;
              heapClassInst.heap32[fp + numDefineNeg240] = 0;
              heapClassInst.heap32[r5 + 1] = 0;
              heapClassInst.heap32[r5 + numDefine2] = 0;
              heapClassInst.heap32[r5 + numDefine3] = 0;
              heapClassInst.heap32[g0] = r2;
              heapClassInst.heap32[g0 + 1] = numDefine53216;
              heapClassInst.heap32[g0 + numDefine2] = r0;
              r0 = numDefine8;
              f0 = 1;
              f1 = 0;
              znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
              f2 = f1;
              f3 = f0;
              f4 = f1;
              repeat253: while (true) {
                r5 = numDefine24;
                repeat255: while (true) {
                  f5 = numDefineFloat952;
                  f6 = 0;
                  f7 = f3 * f0;
                  f8 = f4 * f6;
                  f9 = f3 * f5;
                  f10 = f1 * f6;
                  f7 = f8 + f7;
                  f11 = f2 * f5;
                  f9 = f10 + f9;
                  f12 = f2 * f0;
                  f13 = f1 * f0;
                  f14 = f2 * f6;
                  f7 = f7 + f11;
                  f9 = f9 - f12;
                  f11 = f13 + f14;
                  f12 = f4 * f5;
                  f5 = f1 * f5;
                  f13 = f4 * f0;
                  f11 = f11 - f12;
                  f12 = f4 * f4;
                  f15 = f3 * f3;
                  f16 = f4 * f7;
                  f17 = f1 * f9;
                  f5 = f5 + f13;
                  f13 = f3 * f6;
                  f5 = f5 - f13;
                  f12 = f12 + f15;
                  f15 = f2 * f2;
                  f18 = f3 * f7;
                  f19 = f1 * f11;
                  f16 = f16 + f17;
                  f17 = f2 * f11;
                  f12 = f12 + f15;
                  f15 = f1 * f1;
                  f7 = f2 * f7;
                  f20 = f1 * f5;
                  f18 = f18 + f19;
                  f19 = f4 * f5;
                  f16 = f16 - f17;
                  f5 = f3 * f5;
                  f17 = numDefine2;
                  f12 = f12 + f15;
                  f7 = f7 + f20;
                  f15 = f3 * f9;
                  f18 = f18 - f19;
                  f9 = f2 * f9;
                  f5 = f16 + f5;
                  f16 = numDefine25;
                  f12 = f17 / f12;
                  f9 = f18 + f9;
                  f5 = f5 + f16;
                  f7 = f7 - f15;
                  f11 = f4 * f11;
                  f15 = f2 * f12;
                  f16 = f3 * f12;
                  f7 = f7 + f11;
                  f9 = f9 + f6;
                  heapClassInst.heapFloat[r3 + numDefine12] = f5;
                  f5 = f3 * f16;
                  f11 = f2 * f15;
                  f7 = f7 + f6;
                  heapClassInst.heapFloat[r3 + numDefine13] = f9;
                  heapClassInst.heapFloat[r3 + numDefine14] = f7;
                  f7 = 1;
                  f9 = f5 + f11;
                  f18 = f4 * f16;
                  f19 = f1 * f15;
                  f9 = f7 - f9;
                  heapClassInst.heap32[r3 + numDefine15] = 0;
                  f20 = f4 * f15;
                  f16 = f1 * f16;
                  f21 = f18 - f19;
                  heapClassInst.heapFloat[fp + numDefineNeg236] = f9;
                  f9 = f4 * f12;
                  f12 = f20 + f16;
                  heapClassInst.heapFloat[r3 + 1] = f21;
                  f21 = f4 * f9;
                  heapClassInst.heapFloat[r3 + numDefine2] = f12;
                  f11 = f21 + f11;
                  f12 = f18 + f19;
                  heapClassInst.heap32[r3 + numDefine3] = 0;
                  f15 = f3 * f15;
                  f9 = f1 * f9;
                  f11 = f7 - f11;
                  heapClassInst.heapFloat[r3 + numDefine4] = f12;
                  f12 = f15 - f9;
                  heapClassInst.heapFloat[r3 + numDefine5] = f11;
                  heapClassInst.heapFloat[r3 + numDefine6] = f12;
                  f11 = f20 - f16;
                  heapClassInst.heap32[r3 + numDefine7] = 0;
                  f5 = f21 + f5;
                  f9 = f15 + f9;
                  heapClassInst.heapFloat[r3 + numDefine8] = f11;
                  f5 = f7 - f5;
                  heapClassInst.heapFloat[r3 + numDefine9] = f9;
                  heapClassInst.heapFloat[r3 + numDefine10] = f5;
                  heapClassInst.heap32[r3 + numDefine11] = 0;
                  r7 = heapClassInst.heap32[r1];
                  r7 = r7 >> numDefine2;
                  f5 = numDefineFloat941;
                  f7 = numDefineFloat176;
                  r7 = heapClassInst.heap32[r7 + numDefine2];
                  f9 = f1 * f5;
                  f11 = f2 * f5;
                  f12 = f4 * f5;
                  f1 = f1 * f7;
                  f5 = f3 * f5;
                  f1 = f1 + f5;
                  f5 = f10 + f12;
                  f9 = f9 - f8;
                  f3 = f3 * f7;
                  f10 = f10 + f11;
                  f4 = f4 * f7;
                  f3 = f9 - f3;
                  f4 = f10 + f4;
                  f9 = f1 + f14;
                  heapClassInst.heap32[g0] = r6;
                  heapClassInst.heap32[g0 + 1] = numDefine53216;
                  heapClassInst.heap32[g0 + numDefine2] = r4;
                  heapClassInst.heap32[g0 + numDefine3] = r2;
                  f5 = f5 + f13;
                  f7 = f2 * f7;
                  r5 = (r5 + -1) | 0;
                  f1 = f3 - f14;
                  f2 = f4 - f13;
                  f3 = f9 - f8;
                  f4 = f5 - f7;
                  functionTable[r7 >> numDefine2](i7);
                  if (!(r5 !== 0)) {
                    break repeat255;
                  }
                }
                f5 = numDefineFloat919;
                f7 = numDefineFloat063;
                f8 = f4 * f5;
                f9 = f1 * f6;
                f10 = f2 * f5;
                f11 = f1 * f7;
                f12 = f3 * f5;
                f1 = f1 * f5;
                f5 = f4 * f6;
                f8 = f9 + f8;
                f13 = f3 * f6;
                f11 = f11 + f12;
                f6 = f2 * f6;
                f9 = f9 + f10;
                f4 = f4 * f7;
                f1 = f1 - f5;
                f3 = f3 * f7;
                f10 = f11 + f6;
                f9 = f9 + f4;
                f1 = f1 - f3;
                f3 = f8 + f13;
                f2 = f2 * f7;
                r0 = (r0 + -1) | 0;
                f4 = f3 - f2;
                f3 = f10 - f5;
                f2 = f9 - f13;
                f1 = f1 - f6;
                f0 = f0 + f17;
                if (r0 === 0) {
                  break repeat161;
                } else {
                  continue repeat253;
                }
              }
            } else {
              if (r0 === numDefine3) {
                r3 = numDefineNeg16;
                r0 = numDefine16;
                f0 = 0;
                f1 = 1;
                f2 = f0;
                repeat260: while (true) {
                  f3 = r3;
                  f4 = numDefine6;
                  f3 = f3 * f4;
                  f5 = numDefineFloat05;
                  f6 = numDefineFloat35;
                  f7 = numDefineFloat249;
                  f8 = numDefineFloat584;
                  f9 = numDefineFloat225;
                  f10 = numDefineFloat604;
                  f11 = numDefineFloat049;
                  f3 = f3 * f5;
                  f5 = f2 + f0;
                  f6 = f1 + f6;
                  f7 = f1 + f7;
                  f8 = f1 + f8;
                  f9 = f1 + f9;
                  f10 = f1 + f10;
                  f11 = f1 + f11;
                  r5 = 0;
                  repeat262: while (true) {
                    heapClassInst.heap32[g0] = numDefine136;
                    znwj(i7);
                    r7 = commonVariable.rg0;
                    r8 = ztv7RagDoll;
                    r9 = r7 >> numDefine2;
                    r10 = heapClassInst.heap32[r1 + 1];
                    r8 = (r8 + numDefine8) | 0;
                    heapClassInst.heap32[r9] = r8;
                    heapClassInst.heap32[r9 + 1] = r10;
                    r8 = heapClassInst.heap32[r2];
                    r9 = (r8 + 1) | 0;
                    heapClassInst.heap32[r2] = r9;
                    f12 = r5;
                    heapClassInst.heap32[g0] = numDefine75;
                    f12 = f12 * f4;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    f12 = f12 + f3;
                    if (r9 !== 0) {
                      r10 = 0;
                      r11 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r11) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r11 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r11;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    r11 = ztv14btCapsuleShape;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    r11 = (r11 + numDefine8) | 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine84039;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine31443;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine84039;
                    r12 = r7 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine2) | 0;
                    heapClassInst.heap32[r12 + numDefine2] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine84039;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine29064;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine84039;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine3) | 0;
                    heapClassInst.heap32[r12 + numDefine3] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine31443;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine54227;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine31443;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine4) | 0;
                    heapClassInst.heap32[r12 + numDefine4] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine40456;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine88057;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine40456;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine5) | 0;
                    heapClassInst.heap32[r12 + numDefine5] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine39248;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine6) | 0;
                    heapClassInst.heap32[r12 + numDefine6] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine40456;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine88057;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine40456;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine7) | 0;
                    heapClassInst.heap32[r12 + numDefine7] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine39248;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine8) | 0;
                    heapClassInst.heap32[r12 + numDefine8] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine64843;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine9) | 0;
                    heapClassInst.heap32[r12 + numDefine9] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine94025;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine67456;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine94025;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r10 = (r8 + numDefine10) | 0;
                    heapClassInst.heap32[r12 + numDefine10] = r9;
                    heapClassInst.heap32[r2] = r10;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r10 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r10 = (r10 - r13) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r9 + r10) | 0;
                      r13 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r9;
                      r9 = r13;
                    }
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r10] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine10;
                    heapClassInst.heap32[r10 + numDefine13] = 1;
                    heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine8] = numDefine64843;
                    heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                    heapClassInst.heap32[r10 + numDefine10] = 0;
                    r8 = (r8 + numDefine11) | 0;
                    heapClassInst.heap32[r12 + numDefine11] = r9;
                    heapClassInst.heap32[r2] = r8;
                    heapClassInst.heap32[g0] = numDefine75;
                    mallocNew(i7);
                    r8 = commonVariable.rg0;
                    if (r8 !== 0) {
                      r9 = 0;
                      r10 = (r8 + numDefine4) | 0;
                      r9 = (r9 - r10) | 0;
                      r9 = r9 & numDefine15;
                      r9 = (r8 + r9) | 0;
                      r10 = (r9 + numDefine4) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r9] = r8;
                      r8 = r10;
                    }
                    r9 = r8 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine2] = 0;
                    heapClassInst.heap32[r9 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r9 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r9 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r9 + numDefine6] = 0;
                    heapClassInst.heap32[r9 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r9] = r11;
                    heapClassInst.heap32[r9 + 1] = numDefine10;
                    heapClassInst.heap32[r9 + numDefine13] = 1;
                    heapClassInst.heap32[r9 + numDefine7] = numDefine94025;
                    heapClassInst.heap32[r9 + numDefine8] = numDefine67456;
                    heapClassInst.heap32[r9 + numDefine9] = numDefine94025;
                    heapClassInst.heap32[r9 + numDefine10] = 0;
                    heapClassInst.heap32[r12 + numDefine12] = r8;
                    r8 = heapClassInst.heap32[r12 + numDefine2];
                    r9 = sp + numDefineNeg880;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg220] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = 0;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f6;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine13] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine3];
                    r9 = sp + numDefineNeg816;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg204] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f7;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine14] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine4];
                    r9 = sp + numDefineNeg752;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg188] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f8;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine15] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine5];
                    r9 = sp + numDefineNeg688;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg172] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineNegFloat642;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f9;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine16] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine6];
                    r9 = sp + numDefineNeg624;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg156] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f10;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine17] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine7];
                    r9 = sp + numDefineNeg560;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg140] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineFloat642;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f9;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine18] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine8];
                    r9 = sp + numDefineNeg496;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg124] = numDefine53216;
                    heapClassInst.heap32[r10 + 1] = 0;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = 0;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f10;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine19] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine9];
                    r9 = sp + numDefineNeg432;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg108] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + 1] = numDefineNeg30432;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineNegFloat279;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f11;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine20] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine10];
                    r9 = sp + numDefineNeg368;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg92] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + 1] = numDefineNeg30432;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = 0;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineNegFloat458;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f11;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine21] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine11];
                    r9 = sp + numDefineNeg304;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg76] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + 1] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = numDefineNeg30432;
                    heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = numDefineNeg83648;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineFloat279;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f13 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f13;
                    heapClassInst.heapFloat[r10 + numDefine13] = f11;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    heapClassInst.heap32[r12 + numDefine22] = commonVariable.rg0;
                    r8 = heapClassInst.heap32[r12 + numDefine12];
                    r9 = sp + numDefineNeg240;
                    r10 = r9 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg60] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + 1] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = numDefineNeg30432;
                    heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = numDefineNeg83648;
                    heapClassInst.heap32[r10 + numDefine9] = 0;
                    f13 = numDefineFloat458;
                    heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                    f12 = f12 + f13;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    heapClassInst.heapFloat[r10 + numDefine12] = f12;
                    heapClassInst.heapFloat[r10 + numDefine13] = f11;
                    heapClassInst.heapFloat[r10 + numDefine14] = f5;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                    r9 = 0;
                    heapClassInst.heap32[r12 + numDefine23] = commonVariable.rg0;
                    repeat297: while (true) {
                      r8 = r9 << numDefine2;
                      r8 = (r7 - r8) | 0;
                      r8 = r8 >> numDefine2;
                      r10 = heapClassInst.heap32[r8 + numDefine13];
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10 + numDefine109] = numDefine43341;
                      heapClassInst.heap32[r10 + numDefine110] = numDefine36634;
                      r10 = heapClassInst.heap32[r8 + numDefine13];
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10 + numDefine55] = numDefine97773;
                      r8 = heapClassInst.heap32[r8 + numDefine13];
                      r8 = r8 >> numDefine2;
                      r9 = (r9 + -1) | 0;
                      heapClassInst.heap32[r8 + numDefine116] = numDefine86381;
                      heapClassInst.heap32[r8 + numDefine117] = numDefine38976;
                      if (!(r9 !== numDefineNeg11)) {
                        break repeat297;
                      }
                    }
                    heapClassInst.heap32[g0] = numDefine748;
                    znwj(i7);
                    r8 = commonVariable.rg0;
                    r9 = heapClassInst.heap32[r12 + numDefine14];
                    r10 = heapClassInst.heap32[r12 + numDefine13];
                    r11 = r8 >> numDefine2;
                    heapClassInst.heap32[r11 + 1] = numDefine4;
                    heapClassInst.heap32[r11 + numDefine2] = -1;
                    r13 = 0;
                    heapClassInst.heap32[r11 + numDefine3] = -1;
                    heapClassInst.heap8[r8 + numDefine16] = r13;
                    heapClassInst.heap32[r11 + numDefine5] = r10;
                    heapClassInst.heap32[r11 + numDefine6] = r9;
                    r9 = ztv17btHingeConstraint;
                    heapClassInst.heap32[r11 + numDefine7] = 0;
                    r9 = (r9 + numDefine8) | 0;
                    heapClassInst.heap32[r11 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r11] = r9;
                    heapClassInst.heap32[r11 + numDefine135] = numDefineNeg30578;
                    heapClassInst.heap32[r11 + numDefine136] = 0;
                    heapClassInst.heap32[r11 + numDefine137] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine138] = 0;
                    heapClassInst.heap32[r11 + numDefine139] = numDefineNeg83648;
                    heapClassInst.heap32[r11 + numDefine140] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine141] = 0;
                    heapClassInst.heap32[r11 + numDefine142] = 0;
                    heapClassInst.heap32[r11 + numDefine143] = numDefineNeg30432;
                    heapClassInst.heap32[r11 + numDefine144] = numDefineNeg83648;
                    heapClassInst.heap32[r11 + numDefine145] = numDefineNeg30578;
                    heapClassInst.heap32[r11 + numDefine146] = 0;
                    heapClassInst.heap32[r11 + numDefine147] = 0;
                    heapClassInst.heap32[r11 + numDefine148] = numDefine84039;
                    heapClassInst.heap32[r11 + numDefine149] = 0;
                    heapClassInst.heap32[r11 + numDefine150] = 0;
                    heapClassInst.heap32[r11 + numDefine151] = numDefineNeg30578;
                    heapClassInst.heap32[r11 + numDefine152] = 0;
                    heapClassInst.heap32[r11 + numDefine153] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine154] = 0;
                    heapClassInst.heap32[r11 + numDefine155] = numDefineNeg83648;
                    heapClassInst.heap32[r11 + numDefine156] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine157] = 0;
                    heapClassInst.heap32[r11 + numDefine158] = 0;
                    heapClassInst.heap32[r11 + numDefine159] = numDefineNeg30432;
                    heapClassInst.heap32[r11 + numDefine160] = numDefineNeg83648;
                    heapClassInst.heap32[r11 + numDefine161] = numDefineNeg30578;
                    heapClassInst.heap32[r11 + numDefine162] = 0;
                    heapClassInst.heap32[r11 + numDefine163] = 0;
                    heapClassInst.heap32[r11 + numDefine164] = numDefineNeg99609;
                    heapClassInst.heap32[r11 + numDefine165] = 0;
                    heapClassInst.heap32[r11 + numDefine166] = 0;
                    heapClassInst.heap8[r8 + numDefine720] = r13;
                    heapClassInst.heap8[r8 + numDefine721] = r13;
                    heapClassInst.heap8[r8 + numDefine723] = r13;
                    heapClassInst.heap8[r8 + numDefine724] = r4;
                    heapClassInst.heap8[r8 + numDefine725] = r13;
                    heapClassInst.heap32[r11 + numDefine183] = 0;
                    heapClassInst.heap32[r11 + numDefine172] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine173] = numDefineNeg30432;
                    heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                    heapClassInst.heap8[r8 + numDefine722] = r13;
                    heapClassInst.heap32[r11 + numDefine179] = numDefine53216;
                    heapClassInst.heap32[g0] = numDefineNeg30853;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    f13 = numDefineNegFloat132;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    r10 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r10 + numDefine172] = f12;
                    heapClassInst.heap32[g0] = numDefine41403;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    heapClassInst.heapFloat[r10 + numDefine173] = f12;
                    heapClassInst.heap32[r10 + numDefine169] = numDefine75494;
                    heapClassInst.heap32[r10 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r10 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine24] = r8;
                    r10 = heapClassInst.heap32[r12 + 1];
                    r11 = r10 >> numDefine2;
                    r11 = heapClassInst.heap32[r11];
                    r11 = r11 >> numDefine2;
                    r11 = heapClassInst.heap32[r11 + numDefine13];
                    heapClassInst.heap32[g0] = r10;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r11 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine596;
                    znwj(i7);
                    r10 = heapClassInst.heap32[r12 + numDefine15];
                    r11 = heapClassInst.heap32[r12 + numDefine14];
                    r14 = commonVariable.rg0 >> numDefine2;
                    heapClassInst.heap32[r14 + 1] = numDefine5;
                    heapClassInst.heap32[r14 + numDefine2] = -1;
                    heapClassInst.heap32[r14 + numDefine3] = -1;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r13;
                    heapClassInst.heap32[r14 + numDefine5] = r11;
                    heapClassInst.heap32[r14 + numDefine6] = r10;
                    heapClassInst.heap32[r14 + numDefine7] = 0;
                    r10 = ztv21btConeTwistConstraint;
                    heapClassInst.heap32[r14 + numDefine8] = numDefine53722;
                    r10 = (r10 + numDefine8) | 0;
                    heapClassInst.heap32[r14] = r10;
                    heapClassInst.heap32[r14 + numDefine72] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine73] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine74] = 0;
                    heapClassInst.heap32[r14 + numDefine75] = 0;
                    heapClassInst.heap32[r14 + numDefine76] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine77] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine78] = 0;
                    heapClassInst.heap32[r14 + numDefine79] = 0;
                    heapClassInst.heap32[r14 + numDefine80] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine81] = 0;
                    heapClassInst.heap32[r14 + numDefine82] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine83] = 0;
                    heapClassInst.heap32[r14 + numDefine84] = 0;
                    heapClassInst.heap32[r14 + numDefine85] = numDefine72647;
                    heapClassInst.heap32[r14 + numDefine86] = 0;
                    heapClassInst.heap32[r14 + numDefine87] = 0;
                    heapClassInst.heap32[r14 + numDefine88] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine89] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine90] = 0;
                    heapClassInst.heap32[r14 + numDefine91] = 0;
                    heapClassInst.heap32[r14 + numDefine92] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine93] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine94] = 0;
                    heapClassInst.heap32[r14 + numDefine95] = 0;
                    heapClassInst.heap32[r14 + numDefine96] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine97] = 0;
                    heapClassInst.heap32[r14 + numDefine98] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine99] = 0;
                    heapClassInst.heap32[r14 + numDefine100] = 0;
                    heapClassInst.heap32[r14 + numDefine101] = numDefineNeg54584;
                    heapClassInst.heap32[r14 + numDefine102] = 0;
                    heapClassInst.heap32[r14 + numDefine103] = 0;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine540] = r13;
                    heapClassInst.heap32[r14 + numDefine128] = 0;
                    heapClassInst.heap32[r14 + numDefine140] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine107] = numDefine81770;
                    heapClassInst.heap32[r14 + numDefine111] = numDefine43341;
                    heapClassInst.heap32[r14 + numDefine145] = 0;
                    heapClassInst.heap32[r14 + numDefine146] = 0;
                    heapClassInst.heap32[r14 + numDefine147] = numDefine20051;
                    heapClassInst.heap32[r14 + numDefine148] = 0;
                    heapClassInst.heap32[r14 + numDefine108] = numDefine52795;
                    heapClassInst.heap32[r14 + numDefine109] = numDefine52795;
                    heapClassInst.heap32[r14 + numDefine110] = numDefine41403;
                    heapClassInst.heap32[r14 + numDefine104] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine105] = numDefine53722;
                    heapClassInst.heap32[r14 + numDefine106] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine25] = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine596;
                    znwj(i7);
                    r11 = heapClassInst.heap32[r12 + numDefine16];
                    r14 = heapClassInst.heap32[r12 + numDefine13];
                    r15 = commonVariable.rg0 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine5;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r10;
                    heapClassInst.heap32[r15 + numDefine72] = numDefineNeg44364;
                    heapClassInst.heap32[r15 + numDefine73] = numDefineNeg44366;
                    heapClassInst.heap32[r15 + numDefine74] = 0;
                    heapClassInst.heap32[r15 + numDefine75] = 0;
                    heapClassInst.heap32[r15 + numDefine76] = numDefine39282;
                    heapClassInst.heap32[r15 + numDefine77] = numDefineNeg44364;
                    heapClassInst.heap32[r15 + numDefine78] = 0;
                    heapClassInst.heap32[r15 + numDefine79] = 0;
                    heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine81] = 0;
                    heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine83] = 0;
                    heapClassInst.heap32[r15 + numDefine84] = numDefineNeg38002;
                    heapClassInst.heap32[r15 + numDefine85] = numDefineNeg52205;
                    heapClassInst.heap32[r15 + numDefine86] = 0;
                    heapClassInst.heap32[r15 + numDefine87] = 0;
                    heapClassInst.heap32[r15 + numDefine88] = numDefineNeg44364;
                    heapClassInst.heap32[r15 + numDefine89] = numDefineNeg44366;
                    heapClassInst.heap32[r15 + numDefine90] = 0;
                    heapClassInst.heap32[r15 + numDefine91] = 0;
                    heapClassInst.heap32[r15 + numDefine92] = numDefine39282;
                    heapClassInst.heap32[r15 + numDefine93] = numDefineNeg44364;
                    heapClassInst.heap32[r15 + numDefine94] = 0;
                    heapClassInst.heap32[r15 + numDefine95] = 0;
                    heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine97] = 0;
                    heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine99] = 0;
                    heapClassInst.heap32[r15 + numDefine100] = 0;
                    heapClassInst.heap32[r15 + numDefine101] = numDefine88057;
                    heapClassInst.heap32[r15 + numDefine102] = 0;
                    heapClassInst.heap32[r15 + numDefine103] = 0;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine540] = r13;
                    heapClassInst.heap32[r15 + numDefine128] = 0;
                    heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                    heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                    heapClassInst.heap32[r15 + numDefine145] = 0;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                    heapClassInst.heap32[r15 + numDefine148] = 0;
                    heapClassInst.heap32[r15 + numDefine108] = numDefine52795;
                    heapClassInst.heap32[r15 + numDefine109] = numDefine52795;
                    heapClassInst.heap32[r15 + numDefine110] = 0;
                    heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine26] = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine748;
                    znwj(i7);
                    r8 = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + numDefine17];
                    r14 = heapClassInst.heap32[r12 + numDefine16];
                    r15 = r8 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine4;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[r8 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r9;
                    heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine136] = 0;
                    heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine138] = 0;
                    heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine141] = 0;
                    heapClassInst.heap32[r15 + numDefine142] = 0;
                    heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = 0;
                    heapClassInst.heap32[r15 + numDefine148] = numDefineNeg95591;
                    heapClassInst.heap32[r15 + numDefine149] = 0;
                    heapClassInst.heap32[r15 + numDefine150] = 0;
                    heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine152] = 0;
                    heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine154] = 0;
                    heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine157] = 0;
                    heapClassInst.heap32[r15 + numDefine158] = 0;
                    heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine162] = 0;
                    heapClassInst.heap32[r15 + numDefine163] = 0;
                    heapClassInst.heap32[r15 + numDefine164] = numDefine39248;
                    heapClassInst.heap32[r15 + numDefine165] = 0;
                    heapClassInst.heap32[r15 + numDefine166] = 0;
                    heapClassInst.heap8[r8 + numDefine720] = r13;
                    heapClassInst.heap8[r8 + numDefine721] = r13;
                    heapClassInst.heap8[r8 + numDefine723] = r13;
                    heapClassInst.heap8[r8 + numDefine724] = r4;
                    heapClassInst.heap8[r8 + numDefine725] = r13;
                    heapClassInst.heap32[r15 + numDefine183] = 0;
                    heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                    heapClassInst.heap8[r8 + numDefine722] = r13;
                    heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                    heapClassInst.heap32[g0] = 0;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    r11 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r11 + numDefine172] = f12;
                    heapClassInst.heap32[g0] = numDefine41403;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    heapClassInst.heapFloat[r11 + numDefine173] = f12;
                    heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                    heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine27] = r8;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine596;
                    znwj(i7);
                    r11 = heapClassInst.heap32[r12 + numDefine18];
                    r14 = heapClassInst.heap32[r12 + numDefine13];
                    r15 = commonVariable.rg0 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine5;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r10;
                    heapClassInst.heap32[r15 + numDefine72] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine73] = numDefineNeg44365;
                    heapClassInst.heap32[r15 + numDefine74] = 0;
                    heapClassInst.heap32[r15 + numDefine75] = 0;
                    heapClassInst.heap32[r15 + numDefine76] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine77] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine78] = 0;
                    heapClassInst.heap32[r15 + numDefine79] = 0;
                    heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine81] = 0;
                    heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine83] = 0;
                    heapClassInst.heap32[r15 + numDefine84] = numDefine45646;
                    heapClassInst.heap32[r15 + numDefine85] = numDefineNeg52205;
                    heapClassInst.heap32[r15 + numDefine86] = 0;
                    heapClassInst.heap32[r15 + numDefine87] = 0;
                    heapClassInst.heap32[r15 + numDefine88] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine89] = numDefineNeg44365;
                    heapClassInst.heap32[r15 + numDefine90] = 0;
                    heapClassInst.heap32[r15 + numDefine91] = 0;
                    heapClassInst.heap32[r15 + numDefine92] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine93] = numDefine39283;
                    heapClassInst.heap32[r15 + numDefine94] = 0;
                    heapClassInst.heap32[r15 + numDefine95] = 0;
                    heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine97] = 0;
                    heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine99] = 0;
                    heapClassInst.heap32[r15 + numDefine100] = 0;
                    heapClassInst.heap32[r15 + numDefine101] = numDefine88057;
                    heapClassInst.heap32[r15 + numDefine102] = 0;
                    heapClassInst.heap32[r15 + numDefine103] = 0;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine540] = r13;
                    heapClassInst.heap32[r15 + numDefine128] = 0;
                    heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                    heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                    heapClassInst.heap32[r15 + numDefine145] = 0;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                    heapClassInst.heap32[r15 + numDefine148] = 0;
                    heapClassInst.heap32[r15 + numDefine108] = numDefine52795;
                    heapClassInst.heap32[r15 + numDefine109] = numDefine52795;
                    heapClassInst.heap32[r15 + numDefine110] = 0;
                    heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine28] = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine748;
                    znwj(i7);
                    r8 = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + numDefine19];
                    r14 = heapClassInst.heap32[r12 + numDefine18];
                    r15 = r8 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine4;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[r8 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r9;
                    heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine136] = 0;
                    heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine138] = 0;
                    heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine141] = 0;
                    heapClassInst.heap32[r15 + numDefine142] = 0;
                    heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = 0;
                    heapClassInst.heap32[r15 + numDefine148] = numDefineNeg95591;
                    heapClassInst.heap32[r15 + numDefine149] = 0;
                    heapClassInst.heap32[r15 + numDefine150] = 0;
                    heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine152] = 0;
                    heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine154] = 0;
                    heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine157] = 0;
                    heapClassInst.heap32[r15 + numDefine158] = 0;
                    heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine162] = 0;
                    heapClassInst.heap32[r15 + numDefine163] = 0;
                    heapClassInst.heap32[r15 + numDefine164] = numDefine39248;
                    heapClassInst.heap32[r15 + numDefine165] = 0;
                    heapClassInst.heap32[r15 + numDefine166] = 0;
                    heapClassInst.heap8[r8 + numDefine720] = r13;
                    heapClassInst.heap8[r8 + numDefine721] = r13;
                    heapClassInst.heap8[r8 + numDefine723] = r13;
                    heapClassInst.heap8[r8 + numDefine724] = r4;
                    heapClassInst.heap8[r8 + numDefine725] = r13;
                    heapClassInst.heap32[r15 + numDefine183] = 0;
                    heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                    heapClassInst.heap8[r8 + numDefine722] = r13;
                    heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                    heapClassInst.heap32[g0] = 0;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    r11 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r11 + numDefine172] = f12;
                    heapClassInst.heap32[g0] = numDefine41403;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    heapClassInst.heapFloat[r11 + numDefine173] = f12;
                    heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                    heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine29] = r8;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine596;
                    znwj(i7);
                    r11 = heapClassInst.heap32[r12 + numDefine20];
                    r14 = heapClassInst.heap32[r12 + numDefine14];
                    r15 = commonVariable.rg0 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine5;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r10;
                    heapClassInst.heap32[r15 + numDefine72] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine73] = numDefine41678;
                    heapClassInst.heap32[r15 + numDefine74] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine75] = 0;
                    heapClassInst.heap32[r15 + numDefine76] = numDefineNeg41970;
                    heapClassInst.heap32[r15 + numDefine77] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine78] = 0;
                    heapClassInst.heap32[r15 + numDefine79] = 0;
                    heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine81] = 0;
                    heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine83] = 0;
                    heapClassInst.heap32[r15 + numDefine84] = numDefineNeg63597;
                    heapClassInst.heap32[r15 + numDefine85] = numDefine84039;
                    heapClassInst.heap32[r15 + numDefine86] = 0;
                    heapClassInst.heap32[r15 + numDefine87] = 0;
                    heapClassInst.heap32[r15 + numDefine88] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine89] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine90] = 0;
                    heapClassInst.heap32[r15 + numDefine91] = 0;
                    heapClassInst.heap32[r15 + numDefine92] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine93] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine94] = 0;
                    heapClassInst.heap32[r15 + numDefine95] = 0;
                    heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine97] = 0;
                    heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine99] = 0;
                    heapClassInst.heap32[r15 + numDefine100] = 0;
                    heapClassInst.heap32[r15 + numDefine101] = numDefineNeg38002;
                    heapClassInst.heap32[r15 + numDefine102] = 0;
                    heapClassInst.heap32[r15 + numDefine103] = 0;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine540] = r13;
                    heapClassInst.heap32[r15 + numDefine128] = 0;
                    heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                    heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                    heapClassInst.heap32[r15 + numDefine145] = 0;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                    heapClassInst.heap32[r15 + numDefine148] = 0;
                    heapClassInst.heap32[r15 + numDefine108] = numDefine41403;
                    heapClassInst.heap32[r15 + numDefine109] = numDefine41403;
                    heapClassInst.heap32[r15 + numDefine110] = 0;
                    heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine30] = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine748;
                    znwj(i7);
                    r8 = commonVariable.rg0;
                    r11 = heapClassInst.heap32[r12 + numDefine21];
                    r14 = heapClassInst.heap32[r12 + numDefine20];
                    r15 = r8 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine4;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[r8 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r9;
                    heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine136] = 0;
                    heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine138] = 0;
                    heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine141] = 0;
                    heapClassInst.heap32[r15 + numDefine142] = 0;
                    heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = 0;
                    heapClassInst.heap32[r15 + numDefine148] = numDefine45646;
                    heapClassInst.heap32[r15 + numDefine149] = 0;
                    heapClassInst.heap32[r15 + numDefine150] = 0;
                    heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine152] = 0;
                    heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine154] = 0;
                    heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine157] = 0;
                    heapClassInst.heap32[r15 + numDefine158] = 0;
                    heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine162] = 0;
                    heapClassInst.heap32[r15 + numDefine163] = 0;
                    heapClassInst.heap32[r15 + numDefine164] = numDefineNeg54584;
                    heapClassInst.heap32[r15 + numDefine165] = 0;
                    heapClassInst.heap32[r15 + numDefine166] = 0;
                    heapClassInst.heap8[r8 + numDefine720] = r13;
                    heapClassInst.heap8[r8 + numDefine721] = r13;
                    heapClassInst.heap8[r8 + numDefine723] = r13;
                    heapClassInst.heap8[r8 + numDefine724] = r4;
                    heapClassInst.heap8[r8 + numDefine725] = r13;
                    heapClassInst.heap32[r15 + numDefine183] = 0;
                    heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                    heapClassInst.heap8[r8 + numDefine722] = r13;
                    heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                    heapClassInst.heap32[g0] = numDefineNeg42245;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    r11 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r11 + numDefine172] = f12;
                    heapClassInst.heap32[g0] = 0;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    heapClassInst.heapFloat[r11 + numDefine173] = f12;
                    heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                    heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine31] = r8;
                    r11 = heapClassInst.heap32[r12 + 1];
                    r14 = r11 >> numDefine2;
                    r14 = heapClassInst.heap32[r14];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine13];
                    heapClassInst.heap32[g0] = r11;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r14 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine596;
                    znwj(i7);
                    r11 = heapClassInst.heap32[r12 + numDefine22];
                    r14 = heapClassInst.heap32[r12 + numDefine14];
                    r15 = commonVariable.rg0 >> numDefine2;
                    heapClassInst.heap32[r15 + 1] = numDefine5;
                    heapClassInst.heap32[r15 + numDefine2] = -1;
                    heapClassInst.heap32[r15 + numDefine3] = -1;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r13;
                    heapClassInst.heap32[r15 + numDefine5] = r14;
                    heapClassInst.heap32[r15 + numDefine6] = r11;
                    heapClassInst.heap32[r15 + numDefine7] = 0;
                    heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r15] = r10;
                    heapClassInst.heap32[r15 + numDefine72] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine73] = 0;
                    heapClassInst.heap32[r15 + numDefine74] = 0;
                    heapClassInst.heap32[r15 + numDefine75] = 0;
                    heapClassInst.heap32[r15 + numDefine76] = 0;
                    heapClassInst.heap32[r15 + numDefine77] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine78] = 0;
                    heapClassInst.heap32[r15 + numDefine79] = 0;
                    heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine81] = 0;
                    heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine83] = 0;
                    heapClassInst.heap32[r15 + numDefine84] = numDefine20051;
                    heapClassInst.heap32[r15 + numDefine85] = numDefine84039;
                    heapClassInst.heap32[r15 + numDefine86] = 0;
                    heapClassInst.heap32[r15 + numDefine87] = 0;
                    heapClassInst.heap32[r15 + numDefine88] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine89] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine90] = 0;
                    heapClassInst.heap32[r15 + numDefine91] = 0;
                    heapClassInst.heap32[r15 + numDefine92] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine93] = numDefineNeg30578;
                    heapClassInst.heap32[r15 + numDefine94] = 0;
                    heapClassInst.heap32[r15 + numDefine95] = 0;
                    heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                    heapClassInst.heap32[r15 + numDefine97] = 0;
                    heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine99] = 0;
                    heapClassInst.heap32[r15 + numDefine100] = 0;
                    heapClassInst.heap32[r15 + numDefine101] = numDefineNeg38002;
                    heapClassInst.heap32[r15 + numDefine102] = 0;
                    heapClassInst.heap32[r15 + numDefine103] = 0;
                    heapClassInst.heap8[commonVariable.rg0 + numDefine540] = r13;
                    heapClassInst.heap32[r15 + numDefine128] = 0;
                    heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                    heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                    heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                    heapClassInst.heap32[r15 + numDefine145] = 0;
                    heapClassInst.heap32[r15 + numDefine146] = 0;
                    heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                    heapClassInst.heap32[r15 + numDefine148] = 0;
                    heapClassInst.heap32[r15 + numDefine108] = numDefine41403;
                    heapClassInst.heap32[r15 + numDefine109] = numDefine41403;
                    heapClassInst.heap32[r15 + numDefine110] = 0;
                    heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                    heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                    heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine32] = commonVariable.rg0;
                    r10 = heapClassInst.heap32[r12 + 1];
                    r11 = r10 >> numDefine2;
                    r11 = heapClassInst.heap32[r11];
                    r11 = r11 >> numDefine2;
                    r11 = heapClassInst.heap32[r11 + numDefine13];
                    heapClassInst.heap32[g0] = r10;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r11 >> numDefine2](i7);
                    heapClassInst.heap32[g0] = numDefine748;
                    znwj(i7);
                    r8 = commonVariable.rg0;
                    r10 = heapClassInst.heap32[r12 + numDefine23];
                    r11 = heapClassInst.heap32[r12 + numDefine22];
                    r14 = r8 >> numDefine2;
                    heapClassInst.heap32[r14 + 1] = numDefine4;
                    heapClassInst.heap32[r14 + numDefine2] = -1;
                    heapClassInst.heap32[r14 + numDefine3] = -1;
                    heapClassInst.heap8[r8 + numDefine16] = r13;
                    heapClassInst.heap32[r14 + numDefine5] = r11;
                    heapClassInst.heap32[r14 + numDefine6] = r10;
                    heapClassInst.heap32[r14 + numDefine7] = 0;
                    heapClassInst.heap32[r14 + numDefine8] = numDefine53722;
                    heapClassInst.heap32[r14] = r9;
                    heapClassInst.heap32[r14 + numDefine135] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine136] = 0;
                    heapClassInst.heap32[r14 + numDefine137] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine138] = 0;
                    heapClassInst.heap32[r14 + numDefine139] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine140] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine141] = 0;
                    heapClassInst.heap32[r14 + numDefine142] = 0;
                    heapClassInst.heap32[r14 + numDefine143] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine144] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine145] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine146] = 0;
                    heapClassInst.heap32[r14 + numDefine147] = 0;
                    heapClassInst.heap32[r14 + numDefine148] = numDefine45646;
                    heapClassInst.heap32[r14 + numDefine149] = 0;
                    heapClassInst.heap32[r14 + numDefine150] = 0;
                    heapClassInst.heap32[r14 + numDefine151] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine152] = 0;
                    heapClassInst.heap32[r14 + numDefine153] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine154] = 0;
                    heapClassInst.heap32[r14 + numDefine155] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine156] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine157] = 0;
                    heapClassInst.heap32[r14 + numDefine158] = 0;
                    heapClassInst.heap32[r14 + numDefine159] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine160] = numDefineNeg83648;
                    heapClassInst.heap32[r14 + numDefine161] = numDefineNeg30578;
                    heapClassInst.heap32[r14 + numDefine162] = 0;
                    heapClassInst.heap32[r14 + numDefine163] = 0;
                    heapClassInst.heap32[r14 + numDefine164] = numDefineNeg54584;
                    heapClassInst.heap32[r14 + numDefine165] = 0;
                    heapClassInst.heap32[r14 + numDefine166] = 0;
                    heapClassInst.heap8[r8 + numDefine720] = r13;
                    heapClassInst.heap8[r8 + numDefine721] = r13;
                    heapClassInst.heap8[r8 + numDefine723] = r13;
                    heapClassInst.heap8[r8 + numDefine724] = r4;
                    heapClassInst.heap8[r8 + numDefine725] = r13;
                    heapClassInst.heap32[r14 + numDefine183] = 0;
                    heapClassInst.heap32[r14 + numDefine172] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine173] = numDefineNeg30432;
                    heapClassInst.heap32[r14 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r14 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r14 + numDefine169] = numDefine75494;
                    heapClassInst.heap8[r8 + numDefine722] = r13;
                    heapClassInst.heap32[r14 + numDefine179] = numDefine53216;
                    heapClassInst.heap32[g0] = numDefineNeg42245;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f14 = numDefineFloat132;
                      if (f12 > f14) {
                        f14 = numDefineNegFloat265;
                        f12 = f12 + f14;
                      }
                    } else {
                      f14 = numDefineFloat265;
                      f12 = f12 + f14;
                    }
                    r9 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r9 + numDefine172] = f12;
                    heapClassInst.heap32[g0] = 0;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f12 = commonVariable.fg0;
                    if (f12 >= f13) {
                      f13 = numDefineFloat132;
                      if (f12 > f13) {
                        f13 = numDefineNegFloat265;
                        f12 = f12 + f13;
                      }
                    } else {
                      f13 = numDefineFloat265;
                      f12 = f12 + f13;
                    }
                    heapClassInst.heapFloat[r9 + numDefine173] = f12;
                    heapClassInst.heap32[r9 + numDefine169] = numDefine75494;
                    heapClassInst.heap32[r9 + numDefine170] = numDefine53722;
                    heapClassInst.heap32[r9 + numDefine171] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine33] = r8;
                    r9 = heapClassInst.heap32[r12 + 1];
                    r10 = r9 >> numDefine2;
                    r10 = heapClassInst.heap32[r10];
                    r10 = r10 >> numDefine2;
                    r10 = heapClassInst.heap32[r10 + numDefine13];
                    heapClassInst.heap32[g0] = r9;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable[r10 >> numDefine2](i7);
                    r8 = heapClassInst.heap32[r1 + numDefine10];
                    r9 = heapClassInst.heap32[r1 + numDefine9];
                    if (r8 === r9) {
                      r10 = r9 << 1;
                      r10 = r9 === 0 ? r4 : r10;
                      if (!(r8 >= r10)) {
                        if (r10 !== 0) {
                          r8 = heapClassInst.heap32[r2];
                          r11 = r10 << numDefine2;
                          r8 = (r8 + 1) | 0;
                          r11 = r11 | numDefine3;
                          heapClassInst.heap32[r2] = r8;
                          r8 = (r11 + numDefine16) | 0;
                          heapClassInst.heap32[g0] = r8;
                          mallocNew(i7);
                          r8 = commonVariable.rg0;
                          if (r8 !== 0) {
                            r11 = (r8 + numDefine4) | 0;
                            r11 = (r13 - r11) | 0;
                            r11 = r11 & numDefine15;
                            r11 = (r8 + r11) | 0;
                            r12 = (r11 + numDefine4) | 0;
                            r11 = r11 >> numDefine2;
                            heapClassInst.heap32[r11] = r8;
                            r8 = r12;
                          }
                        } else {
                          r8 = 0;
                        }
                        repeat358: do {
                          if (r9 < 1) {
                            r11 = heapClassInst.heap32[r1 + numDefine11];
                          } else {
                            while (true) {
                              r11 = heapClassInst.heap32[r1 + numDefine11];
                              r12 = r13 << numDefine2;
                              r14 = (r11 + r12) | 0;
                              r14 = r14 >> numDefine2;
                              r12 = (r8 + r12) | 0;
                              r14 = heapClassInst.heap32[r14];
                              r13 = (r13 + 1) | 0;
                              r12 = r12 >> numDefine2;
                              heapClassInst.heap32[r12] = r14;
                              if (!(r9 !== r13)) {
                                break repeat358;
                              }
                            }
                          }
                        } while (false);
                        if (r11 !== 0) {
                          r12 = heapClassInst.heapU8[r6 + numDefine48];
                          if (r12 !== 0) {
                            r9 = gNumAlignedFree;
                            r9 = r9 >> numDefine2;
                            r12 = heapClassInst.heap32[r9];
                            r12 = (r12 + 1) | 0;
                            r11 = r11 >> numDefine2;
                            heapClassInst.heap32[r9] = r12;
                            r9 = heapClassInst.heap32[r11 + -1];
                            heapClassInst.heap32[g0] = r9;
                            free(i7);
                            r9 = heapClassInst.heap32[r1 + numDefine9];
                          }
                          heapClassInst.heap32[r1 + numDefine11] = 0;
                        }
                        heapClassInst.heap8[r6 + numDefine48] = r4;
                        heapClassInst.heap32[r1 + numDefine11] = r8;
                        heapClassInst.heap32[r1 + numDefine10] = r10;
                      }
                    }
                    r8 = r9 << numDefine2;
                    r9 = heapClassInst.heap32[r1 + numDefine11];
                    r8 = (r9 + r8) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8] = r7;
                    r7 = heapClassInst.heap32[r1 + numDefine9];
                    r5 = (r5 + 1) | 0;
                    r7 = (r7 + 1) | 0;
                    heapClassInst.heap32[r1 + numDefine9] = r7;
                    if (!(r0 !== r5)) {
                      break repeat262;
                    }
                  }
                  f3 = numDefine7;
                  f4 = numDefineNeg2;
                  r0 = (r0 + -1) | 0;
                  f1 = f1 + f3;
                  f2 = f2 + f4;
                  r3 = (r3 + 1) | 0;
                  if (r0 === 0) {
                    break repeat161;
                  } else {
                    continue repeat260;
                  }
                }
              }
            }
          }
        }
      } while (false);
      return;
    case numDefine46:
      r0 = twoEStr674;
      r1 = twoEStr573;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine53;
      assertNew(i7);
      break;
    default:
      break;
  }
}

function globalDz6mymainiPPc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zl14benchmarkDemo4;
  r1 = ztv13BenchmarkDemo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn13BenchmarkDemo11exitPhysicsEv(i7);
  r1 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine48];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine11] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine48] = r1;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine6];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine28];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine6] = 0;
  }
  heapClassInst.heap8[r0 + numDefine28] = r1;
  heapClassInst.heap32[r2 + numDefine6] = 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine5] = 0;
  return;
}

function zn14BenchmarkDemo4D1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14BenchmarkDemo4;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn13BenchmarkDemoD2Ev(i7);
  return;
}

function zn14BenchmarkDemo4D0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14BenchmarkDemo4;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn13BenchmarkDemoD2Ev(i7);
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function draw(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zl14benchmarkDemo4;
  heapClassInst.heap32[g0] = r0;
  zn13BenchmarkDemo20clientMoveAndDisplayEv(i7);
  return;
}

function zn13BenchmarkDemoD2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13BenchmarkDemo;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn13BenchmarkDemo11exitPhysicsEv(i7);
  r1 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine48];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine11] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine48] = r1;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine6];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine28];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine6] = 0;
  }
  heapClassInst.heap8[r0 + numDefine28] = r1;
  heapClassInst.heap32[r2 + numDefine6] = 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine5] = 0;
  return;
}

function initNew(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = gDisableDeactivation;
  r1 = 1;
  heapClassInst.heap8[r0] = r1;
  zn13BenchmarkDemo11initPhysicsEv(i7);
  return;
}

function zn15btNullPairCache23getOverlappingPairArrayEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = (r0 + numDefine4) | 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache20cleanOverlappingPairER16btBroadphasePairP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function znk15btNullPairCache22getNumOverlappingPairsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache24setOverlapFilterCallbackEP23btOverlapFilterCallback(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache26processAllOverlappingPairsEP17btOverlapCallbackP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache8findPairEP17btBroadphaseProxyS1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache18hasDeferredRemovalEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 1;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache28setInternalGhostPairCallbackEP25btOverlappingPairCallback(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache18addOverlappingPairEP17btBroadphaseProxyS1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache21removeOverlappingPairEP17btBroadphaseProxyS1P12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache20sortOverlappingPairsEP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btNullPairCache26getOverlappingPairArrayPtrEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine4];
  commonVariable.rg0 = r0;
  return;
}

function znk15btNullPairCache26getOverlappingPairArrayPtrEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine4];
  commonVariable.rg0 = r0;
  return;
}

function zn15btNullPairCacheD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv15btNullPairCache;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  return;
}

function zn15btNullPairCacheD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv15btNullPairCache;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znk20btAxisSweep3InternalItE7getAabbEP17btBroadphaseProxyR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine4];
  heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine5];
  r2 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine8];
  heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine9];
  heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine10];
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine11];
  return;
}

function zn20btAxisSweep3InternalItE23getOverlappingPairCacheEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine23];
  commonVariable.rg0 = r0;
  return;
}

function znk20btAxisSweep3InternalItE23getOverlappingPairCacheEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine23];
  commonVariable.rg0 = r0;
  return;
}

function znk20btAxisSweep3InternalItE17getBroadphaseAabbER9btVector3S2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine2];
  heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine3];
  r2 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine6];
  heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine7];
  heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  return;
}

function zn20btAxisSweep3InternalItE9resetPoolEP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
  if (!(r1 !== 0)) {
    r1 = 1;
    heapClassInst.heap16[(r0 + numDefine64) >> 1] = r1;
    r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
    if (uint(r2) > uint(1)) {
      r3 = numDefine2;
      repeat5: while (true) {
        r2 = r1 & numDefine65535;
        r4 = r0 >> numDefine2;
        r2 = r2 << numDefine6;
        r4 = heapClassInst.heap32[r4 + numDefine15];
        r2 = (r4 + r2) | 0;
        heapClassInst.heap16[(r2 + numDefine48) >> 1] = r3;
        r1 = (r1 + 1) | 0;
        r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
        r3 = (r3 + 1) | 0;
        r4 = r1 & numDefine65535;
        if (!(uint(r2) > uint(r4))) {
          break repeat5;
        }
      }
    }
    r1 = r2 & numDefine65535;
    r0 = r0 >> numDefine2;
    r1 = r1 << numDefine6;
    r0 = heapClassInst.heap32[r0 + numDefine15];
    r0 = (r1 + r0) | 0;
    r1 = 0;
    heapClassInst.heap16[(r0 + numDefineNeg16) >> 1] = r1;
  }
  return;
}

function zn20btAxisSweep3InternalItE10printStatsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn20btAxisSweep3InternalItE8aabbTestERK9btVector3S3R24btBroadphaseAabbCallback(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine27];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  if (r2 !== 0) {
    r0 = r2 >> numDefine2;
    r0 = heapClassInst.heap32[r0];
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine7];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r5;
    functionTable[r0 >> numDefine2](i7);
    return;
  } else {
    r2 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
    r2 = r2 << 1;
    r2 = r2 | 1;
    if (!(r2 === 1)) {
      r2 = 1;
      r6 = numDefine2;
      repeat6: while (true) {
        r7 = r6;
        r6 = r2 & numDefine65535;
        r8 = heapClassInst.heap32[r1 + numDefine17];
        r6 = r6 << numDefine2;
        r9 = heapClassInst.heapU8[r8 + r6];
        r9 = r9 & 1;
        if (!(r9 === 0)) {
          r6 = (r8 + r6) | 0;
          r6 = heapClassInst.heapU16[(r6 + numDefine2) >> 1];
          r8 = heapClassInst.heap32[r1 + numDefine15];
          r6 = r6 << numDefine6;
          r6 = (r8 + r6) | 0;
          r8 = r3 >> numDefine2;
          r9 = r6 >> numDefine2;
          f0 = heapClassInst.heapFloat[r8];
          f1 = heapClassInst.heapFloat[r9 + numDefine8];
          if (f0 > f1) {
            label = numDefine8;
          } else {
            r10 = r4 >> numDefine2;
            f0 = heapClassInst.heapFloat[r10];
            f1 = heapClassInst.heapFloat[r9 + numDefine4];
            if (f0 < f1) {
              label = numDefine8;
            } else {
              r10 = 1;
              label = numDefine9;
            }
          }
          if (label === numDefine8) {
            r10 = 0;
          }
          f0 = heapClassInst.heapFloat[r8 + numDefine2];
          f1 = heapClassInst.heapFloat[r9 + numDefine10];
          if (f0 > f1) {
            label = numDefine11;
          } else {
            r11 = r4 >> numDefine2;
            f0 = heapClassInst.heapFloat[r11 + numDefine2];
            f1 = heapClassInst.heapFloat[r9 + numDefine6];
            if (f0 < f1) {
              label = numDefine11;
            } else {
              label = numDefine12;
            }
          }
          if (label === numDefine11) {
            r10 = 0;
          }
          f0 = heapClassInst.heapFloat[r8 + 1];
          f1 = heapClassInst.heapFloat[r9 + numDefine9];
          if (!(f0 > f1)) {
            r8 = r4 >> numDefine2;
            f0 = heapClassInst.heapFloat[r8 + 1];
            f1 = heapClassInst.heapFloat[r9 + numDefine5];
            if (!(f0 < f1)) {
              r8 = r10 & numDefine255;
              if (!(r8 === 0)) {
                r8 = r5 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8 + numDefine2];
                heapClassInst.heap32[g0] = r5;
                heapClassInst.heap32[g0 + 1] = r6;
                functionTable[r8 >> numDefine2](i7);
              }
            }
          }
        }
        r8 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
        r6 = (r7 + 1) | 0;
        r2 = (r2 + 1) | 0;
        r8 = r8 << 1;
        r7 = r7 & numDefine65535;
        r8 = r8 | 1;
        if (!(uint(r7) < uint(r8))) {
          break repeat6;
        }
      }
    }
    return;
  }
}

function zn20btAxisSweep3InternalItE7rayTestERK9btVector3S3R23btBroadphaseRayCallbackS3S3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine27];
  r3 = heapClassInst.heap32[fp + numDefine3];
  if (r2 !== 0) {
    r0 = heapClassInst.heap32[fp + 1];
    r1 = heapClassInst.heap32[fp + numDefine2];
    r4 = heapClassInst.heap32[fp + numDefine4];
    r5 = heapClassInst.heap32[fp + numDefine5];
    r6 = r2 >> numDefine2;
    r6 = heapClassInst.heap32[r6];
    r6 = r6 >> numDefine2;
    r6 = heapClassInst.heap32[r6 + numDefine6];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r1;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    heapClassInst.heap32[g0 + numDefine4] = r4;
    heapClassInst.heap32[g0 + numDefine5] = r5;
    functionTable[r6 >> numDefine2](i7);
    return;
  } else {
    r2 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
    r2 = r2 << 1;
    r2 = r2 | 1;
    if (!(r2 === 1)) {
      r2 = 1;
      r4 = numDefine2;
      repeat6: while (true) {
        r5 = r2 & numDefine65535;
        r6 = heapClassInst.heap32[r1 + numDefine17];
        r5 = r5 << numDefine2;
        r7 = heapClassInst.heapU8[r6 + r5];
        r7 = r7 & 1;
        if (!(r7 === 0)) {
          r7 = r3 >> numDefine2;
          r7 = heapClassInst.heap32[r7];
          r7 = r7 >> numDefine2;
          r5 = (r6 + r5) | 0;
          r5 = heapClassInst.heapU16[(r5 + numDefine2) >> 1];
          r6 = heapClassInst.heap32[r7 + numDefine2];
          r7 = heapClassInst.heap32[r1 + numDefine15];
          r5 = r5 << numDefine6;
          r5 = (r7 + r5) | 0;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r5;
          functionTable[r6 >> numDefine2](i7);
        }
        r5 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
        r6 = (r4 + 1) | 0;
        r2 = (r2 + 1) | 0;
        r5 = r5 << 1;
        r7 = r4 & numDefine65535;
        r5 = r5 | 1;
        r4 = r6;
        if (!(uint(r7) < uint(r5))) {
          break repeat6;
        }
      }
    }
    return;
  }
}

function zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 << numDefine2;
  r2 = (r1 + r2) | 0;
  r2 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = 1;
  r2 = heapClassInst.heap32[r2 + numDefine17];
  r3 = r3 << numDefine2;
  r2 = (r2 + r3) | 0;
  r3 = r4 << r0;
  r3 = r3 & numDefine3;
  r1 = r1 >> numDefine2;
  r5 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
  r4 = r4 << r3;
  r6 = heapClassInst.heap32[r1 + numDefine15];
  r5 = r5 << numDefine6;
  r4 = r4 & numDefine3;
  r5 = (r6 + r5) | 0;
  r3 = r3 << 1;
  r6 = (r5 + numDefine48) | 0;
  r4 = r4 << 1;
  r5 = (r5 + numDefine54) | 0;
  r0 = r0 << 1;
  r7 = heapClassInst.heap32[fp + numDefine3];
  r8 = (r5 + r3) | 0;
  r9 = (r6 + r3) | 0;
  r10 = (r5 + r4) | 0;
  r6 = (r6 + r4) | 0;
  r5 = (r5 + r0) | 0;
  r2 = (r2 + numDefine4) | 0;
  repeat1: while (true) {
    r11 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
    if (r11 === 0) {
      break repeat1;
    } else {
      r12 = heapClassInst.heapU16[r2 >> 1];
      r13 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
      if (uint(r13) >= uint(r12)) {
        r13 = heapClassInst.heap32[r1 + numDefine15];
        r11 = r11 & numDefine65535;
        r12 = r12 & 1;
        if (r12 !== 0) {
          r11 = r11 << numDefine6;
          r11 = (r13 + r11) | 0;
          r11 = (r11 + r0) | 0;
          r12 = heapClassInst.heapU16[(r11 + numDefine54) >> 1];
          r12 = (r12 + -1) | 0;
          heapClassInst.heap16[(r11 + numDefine54) >> 1] = r12;
        } else {
          if (!(r7 === 0)) {
            r12 = r11 << numDefine6;
            r12 = (r13 + r12) | 0;
            r14 = (r12 + r3) | 0;
            r15 = heapClassInst.heapU16[r8 >> 1];
            r16 = heapClassInst.heapU16[(r14 + numDefine48) >> 1];
            if (!(uint(r15) < uint(r16))) {
              r14 = heapClassInst.heapU16[(r14 + numDefine54) >> 1];
              r15 = heapClassInst.heapU16[r9 >> 1];
              if (!(uint(r14) < uint(r15))) {
                r14 = (r12 + r4) | 0;
                r15 = heapClassInst.heapU16[r10 >> 1];
                r16 = heapClassInst.heapU16[(r14 + numDefine48) >> 1];
                if (!(uint(r15) < uint(r16))) {
                  r14 = heapClassInst.heapU16[(r14 + numDefine54) >> 1];
                  r15 = heapClassInst.heapU16[r6 >> 1];
                  if (!(uint(r14) < uint(r15))) {
                    r14 = heapClassInst.heap32[r1 + numDefine23];
                    r15 = r14 >> numDefine2;
                    r15 = heapClassInst.heap32[r15];
                    r15 = r15 >> numDefine2;
                    r16 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
                    r15 = heapClassInst.heap32[r15 + numDefine2];
                    r16 = r16 << numDefine6;
                    r16 = (r13 + r16) | 0;
                    heapClassInst.heap32[g0] = r14;
                    heapClassInst.heap32[g0 + 1] = r16;
                    heapClassInst.heap32[g0 + numDefine2] = r12;
                    functionTable[r15 >> numDefine2](i7);
                    r14 = heapClassInst.heap32[r1 + numDefine24];
                    if (!(r14 === 0)) {
                      r15 = r14 >> numDefine2;
                      r15 = heapClassInst.heap32[r15];
                      r15 = r15 >> numDefine2;
                      r15 = heapClassInst.heap32[r15 + numDefine2];
                      heapClassInst.heap32[g0] = r14;
                      heapClassInst.heap32[g0 + 1] = r16;
                      heapClassInst.heap32[g0 + numDefine2] = r12;
                      functionTable[r15 >> numDefine2](i7);
                    }
                  }
                }
              }
            }
          }
          r11 = r11 << numDefine6;
          r11 = (r13 + r11) | 0;
          r11 = (r11 + r0) | 0;
          r12 = heapClassInst.heapU16[(r11 + numDefine48) >> 1];
          r12 = (r12 + -1) | 0;
          heapClassInst.heap16[(r11 + numDefine48) >> 1] = r12;
        }
        r11 = heapClassInst.heapU16[r5 >> 1];
        r11 = (r11 + 1) | 0;
        heapClassInst.heap16[r5 >> 1] = r11;
        r11 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
        r12 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
        r13 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
        r14 = heapClassInst.heapU16[r2 >> 1];
        heapClassInst.heap16[(r2 + numDefineNeg4) >> 1] = r14;
        heapClassInst.heap16[(r2 + numDefineNeg2) >> 1] = r13;
        r13 = (r2 + numDefine4) | 0;
        heapClassInst.heap16[r2 >> 1] = r12;
        heapClassInst.heap16[(r2 + numDefine2) >> 1] = r11;
        r2 = r13;
        continue repeat1;
      } else {
        break repeat1;
      }
    }
  }
  return;
}

function zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 << numDefine2;
  r2 = (r1 + r2) | 0;
  r2 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[r2 + numDefine17];
  r3 = r3 << numDefine2;
  r2 = (r2 + r3) | 0;
  r1 = r1 >> numDefine2;
  r3 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
  r4 = 1;
  r5 = r4 << r0;
  r6 = heapClassInst.heap32[r1 + numDefine15];
  r3 = r3 << numDefine6;
  r5 = r5 & numDefine3;
  r3 = (r6 + r3) | 0;
  r0 = r0 << 1;
  r3 = (r3 + r0) | 0;
  r4 = r4 << r5;
  r6 = heapClassInst.heap32[fp + numDefine3];
  r7 = heapClassInst.heap32[fp + numDefine4];
  r3 = (r3 + numDefine48) | 0;
  r4 = r4 & numDefine3;
  r2 = (r2 + numDefine4) | 0;
  repeat1: while (true) {
    r8 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
    if (r8 === 0) {
      break repeat1;
    } else {
      r9 = heapClassInst.heapU16[r2 >> 1];
      r10 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
      if (uint(r10) >= uint(r9)) {
        r10 = heapClassInst.heap32[r1 + numDefine15];
        r8 = r8 & numDefine65535;
        r9 = r9 & 1;
        if (r9 === 0) {
          r8 = r8 << numDefine6;
          r8 = (r10 + r8) | 0;
          r8 = (r8 + r0) | 0;
          r9 = heapClassInst.heapU16[(r8 + numDefine48) >> 1];
          r9 = (r9 + -1) | 0;
          heapClassInst.heap16[(r8 + numDefine48) >> 1] = r9;
        } else {
          if (!(r7 === 0)) {
            r9 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
            r9 = r9 << numDefine6;
            r11 = r8 << numDefine6;
            r9 = (r10 + r9) | 0;
            r12 = r5 << 1;
            r11 = (r10 + r11) | 0;
            r13 = (r9 + r12) | 0;
            r12 = (r11 + r12) | 0;
            r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
            r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
            if (!(uint(r14) < uint(r15))) {
              r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
              r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
              if (!(uint(r12) < uint(r13))) {
                r12 = r4 << 1;
                r13 = (r9 + r12) | 0;
                r12 = (r11 + r12) | 0;
                r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
                r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
                if (!(uint(r14) < uint(r15))) {
                  r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                  r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                  if (!(uint(r12) < uint(r13))) {
                    r12 = heapClassInst.heap32[r1 + numDefine23];
                    r13 = r12 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13 + numDefine3];
                    heapClassInst.heap32[g0] = r12;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    heapClassInst.heap32[g0 + numDefine3] = r6;
                    functionTable[r13 >> numDefine2](i7);
                    r12 = heapClassInst.heap32[r1 + numDefine24];
                    if (!(r12 === 0)) {
                      r13 = r12 >> numDefine2;
                      r13 = heapClassInst.heap32[r13];
                      r13 = r13 >> numDefine2;
                      r13 = heapClassInst.heap32[r13 + numDefine3];
                      heapClassInst.heap32[g0] = r12;
                      heapClassInst.heap32[g0 + 1] = r9;
                      heapClassInst.heap32[g0 + numDefine2] = r11;
                      heapClassInst.heap32[g0 + numDefine3] = r6;
                      functionTable[r13 >> numDefine2](i7);
                    }
                  }
                }
              }
            }
          }
          r8 = r8 << numDefine6;
          r8 = (r10 + r8) | 0;
          r8 = (r8 + r0) | 0;
          r9 = heapClassInst.heapU16[(r8 + numDefine54) >> 1];
          r9 = (r9 + -1) | 0;
          heapClassInst.heap16[(r8 + numDefine54) >> 1] = r9;
        }
        r8 = heapClassInst.heapU16[r3 >> 1];
        r8 = (r8 + 1) | 0;
        heapClassInst.heap16[r3 >> 1] = r8;
        r8 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
        r9 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
        r10 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
        r11 = heapClassInst.heapU16[r2 >> 1];
        heapClassInst.heap16[(r2 + numDefineNeg4) >> 1] = r11;
        heapClassInst.heap16[(r2 + numDefineNeg2) >> 1] = r10;
        r10 = (r2 + numDefine4) | 0;
        heapClassInst.heap16[r2 >> 1] = r9;
        heapClassInst.heap16[(r2 + numDefine2) >> 1] = r8;
        r2 = r10;
        continue repeat1;
      } else {
        break repeat1;
      }
    }
  }
  return;
}

function zn20btAxisSweep3InternalItE7setAabbEP17btBroadphaseProxyRK9btVector3S5P12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine2;
  r3 = r1 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine4] = heapClassInst.heap32[r2];
  heapClassInst.heap32[r3 + numDefine5] = heapClassInst.heap32[r2 + 1];
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[r3 + numDefine6] = heapClassInst.heap32[r2 + numDefine6];
  heapClassInst.heap32[r3 + numDefine7] = heapClassInst.heap32[r2 + numDefine7];
  r5 = r4 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine8] = heapClassInst.heap32[r5];
  heapClassInst.heap32[r3 + numDefine9] = heapClassInst.heap32[r5 + 1];
  r6 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r3 + numDefine10] = heapClassInst.heap32[r5 + numDefine2];
  heapClassInst.heap32[r3 + numDefine11] = heapClassInst.heap32[r5 + numDefine3];
  r7 = r6 >> numDefine2;
  r1 = heapClassInst.heapU16[(r1 + numDefine12) >> 1];
  r8 = heapClassInst.heap32[r7 + numDefine15];
  f0 = heapClassInst.heapFloat[r2];
  f1 = heapClassInst.heapFloat[r2 + 1];
  f2 = heapClassInst.heapFloat[r2 + numDefine2];
  r2 = sp + numDefineNeg6;
  heapClassInst.heap32[g0] = r6;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heapFloat[g0 + numDefine2] = f0;
  heapClassInst.heapFloat[g0 + numDefine3] = f1;
  heapClassInst.heapFloat[g0 + numDefine4] = f2;
  heapClassInst.heap32[g0 + numDefine5] = 0;
  znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
  f0 = heapClassInst.heapFloat[r5];
  f1 = heapClassInst.heapFloat[r5 + 1];
  f2 = heapClassInst.heapFloat[r5 + numDefine2];
  r1 = r1 << numDefine6;
  r5 = sp + numDefineNeg12;
  r1 = (r8 + r1) | 0;
  heapClassInst.heap32[g0] = r6;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heapFloat[g0 + numDefine2] = f0;
  heapClassInst.heapFloat[g0 + numDefine3] = f1;
  heapClassInst.heapFloat[g0 + numDefine4] = f2;
  heapClassInst.heap32[g0 + numDefine5] = 1;
  r8 = heapClassInst.heap32[fp + numDefine4];
  r1 = (r1 + numDefine48) | 0;
  r9 = 0;
  znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
  r10 = r9;
  repeat1: while (true) {
    r11 = r9 << numDefine2;
    r12 = r9 << 1;
    r13 = (r1 - r12) | 0;
    r11 = (r6 - r11) | 0;
    r14 = heapClassInst.heapU16[r13 >> 1];
    r13 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
    r11 = r11 >> numDefine2;
    r15 = (r2 - r12) | 0;
    r12 = (r5 - r12) | 0;
    r16 = heapClassInst.heap32[r11 + numDefine17];
    r17 = r14 << numDefine2;
    r18 = r13 << numDefine2;
    r15 = heapClassInst.heapU16[r15 >> 1];
    r19 = heapClassInst.heapU16[(r16 + r17) >> 1];
    r20 = heapClassInst.heapU16[(r16 + r18) >> 1];
    r12 = heapClassInst.heapU16[r12 >> 1];
    heapClassInst.heap16[(r16 + r17) >> 1] = r15;
    r11 = heapClassInst.heap32[r11 + numDefine17];
    r15 = (r15 - r19) | 0;
    heapClassInst.heap16[(r11 + r18) >> 1] = r12;
    if (!(r15 > -1)) {
      heapClassInst.heap32[g0] = r6;
      heapClassInst.heap32[g0 + 1] = r10;
      heapClassInst.heap32[g0 + numDefine2] = r14;
      heapClassInst.heap32[g0 + numDefine3] = 1;
      zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
    }
    r11 = (r12 - r20) | 0;
    if (!(r11 < 1)) {
      heapClassInst.heap32[g0] = r6;
      heapClassInst.heap32[g0 + 1] = r10;
      heapClassInst.heap32[g0 + numDefine2] = r13;
      heapClassInst.heap32[g0 + numDefine3] = 1;
      zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
    }
    if (!(r15 < 1)) {
      heapClassInst.heap32[g0] = r6;
      heapClassInst.heap32[g0 + 1] = r10;
      heapClassInst.heap32[g0 + numDefine2] = r14;
      heapClassInst.heap32[g0 + numDefine3] = r8;
      heapClassInst.heap32[g0 + numDefine4] = 1;
      zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
    }
    if (!(r11 > -1)) {
      heapClassInst.heap32[g0] = r6;
      heapClassInst.heap32[g0 + 1] = r10;
      heapClassInst.heap32[g0 + numDefine2] = r13;
      heapClassInst.heap32[g0 + numDefine3] = r8;
      heapClassInst.heap32[g0 + numDefine4] = 1;
      zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
    }
    r9 = (r9 + -1) | 0;
    r10 = (r10 + 1) | 0;
    if (r9 !== numDefineNeg3) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  r1 = heapClassInst.heap32[r7 + numDefine27];
  if (!(r1 === 0)) {
    r2 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r2];
    r2 = r2 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + numDefine4];
    r3 = heapClassInst.heap32[r3 + numDefine15];
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    heapClassInst.heap32[g0 + numDefine3] = r4;
    heapClassInst.heap32[g0 + numDefine4] = r8;
    functionTable[r2 >> numDefine2](i7);
  }
  return;
}

function zn20btAxisSweep3InternalItE12destroyProxyEP17btBroadphaseProxyP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine27];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  if (!(r2 === 0)) {
    r5 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r6 = r3 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine3];
    r6 = heapClassInst.heap32[r6 + numDefine15];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r6;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    functionTable[r5 >> numDefine2](i7);
  }
  r2 = heapClassInst.heap32[r1 + numDefine23];
  r5 = r2 >> numDefine2;
  r5 = heapClassInst.heap32[r5];
  r5 = r5 >> numDefine2;
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine3];
  r6 = heapClassInst.heap32[r1 + numDefine15];
  r5 = heapClassInst.heap32[r5 + numDefine14];
  heapClassInst.heap32[g0] = r2;
  functionTable[r5 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  if (!(r2 !== 0)) {
    r2 = heapClassInst.heap32[r1 + numDefine23];
    r5 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine4];
    r7 = r3 & numDefine65535;
    r7 = r7 << numDefine6;
    r7 = (r6 + r7) | 0;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r7;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    functionTable[r5 >> numDefine2](i7);
  }
  r2 = heapClassInst.heap32[r1 + numDefine15];
  r5 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
  r7 = heapClassInst.heapU16[(r2 + numDefine54) >> 1];
  r7 = (r7 + numDefineNeg2) | 0;
  heapClassInst.heap16[(r2 + numDefine54) >> 1] = r7;
  r2 = heapClassInst.heap32[r1 + numDefine15];
  r7 = heapClassInst.heapU16[(r2 + numDefine56) >> 1];
  r7 = (r7 + numDefineNeg2) | 0;
  r8 = r3 & numDefine65535;
  heapClassInst.heap16[(r2 + numDefine56) >> 1] = r7;
  r2 = heapClassInst.heap32[r1 + numDefine15];
  r7 = r8 << numDefine6;
  r9 = heapClassInst.heapU16[(r2 + numDefine58) >> 1];
  r6 = (r6 + r7) | 0;
  r5 = r5 << 1;
  r6 = (r6 + numDefine54) | 0;
  r10 = 0;
  r9 = (r9 + numDefineNeg2) | 0;
  heapClassInst.heap16[(r2 + numDefine58) >> 1] = r9;
  r2 = r10;
  repeat7: while (true) {
    r9 = r2 << numDefine2;
    r9 = (r0 + r9) | 0;
    r9 = r9 >> numDefine2;
    r11 = heapClassInst.heapU16[r6 >> 1];
    r12 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    r9 = heapClassInst.heap32[r9 + numDefine17];
    r13 = r11 << numDefine2;
    heapClassInst.heap16[(r9 + r13) >> 1] = r12;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r11;
    heapClassInst.heap32[g0 + numDefine3] = 0;
    zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
    r11 = heapClassInst.heapU16[(r6 + numDefineNeg6) >> 1];
    r12 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    r13 = r11 << numDefine2;
    heapClassInst.heap16[(r9 + r13) >> 1] = r12;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r11;
    heapClassInst.heap32[g0 + numDefine3] = r4;
    heapClassInst.heap32[g0 + numDefine4] = 0;
    r11 = r5 << numDefine2;
    zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
    r9 = (r9 + r11) | 0;
    heapClassInst.heap16[(r9 + numDefineNeg2) >> 1] = r10;
    r11 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    r2 = (r2 + 1) | 0;
    r6 = (r6 + numDefine2) | 0;
    heapClassInst.heap16[(r9 + numDefineNeg4) >> 1] = r11;
    if (r2 !== numDefine3) {
      continue repeat7;
    } else {
      break repeat7;
    }
  }
  if (!(r8 === 0)) {
    r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
    if (uint(r2) > uint(r8)) {
      r1 = heapClassInst.heap32[r1 + numDefine15];
      r2 = heapClassInst.heapU16[(r0 + numDefine64) >> 1];
      r1 = (r1 + r7) | 0;
      heapClassInst.heap16[(r1 + numDefine48) >> 1] = r2;
      heapClassInst.heap16[(r0 + numDefine64) >> 1] = r3;
      r1 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
      r1 = (r1 + -1) | 0;
      heapClassInst.heap16[(r0 + numDefine56) >> 1] = r1;
      return;
    }
  }
  r0 = twoEStr11;
  r1 = twoEStr112;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine495;
  assertNew(i7);
}

export { receiveMessage2 };

export { flashReady, nullMainAudioDriver };

export { atMandreelAudioCheckBuffersPending, atMandreelAudioCreateBuffer };

export { atMandreelAudioPlayChannel, atMandreelAudioStopChannel, atMandreelAudioSetChannelVolume };

export { atMandreelAudioSetChannelPan, atMandreelAudioSetChannelPitch, atmandreelAudioUseMusicFunctions };

export { atMainAudioDriver };

export { jsMandreelFlashSocketReady };

export { jsMandreelFlashSocketOnError };

export { globalILandscape02Vtx
  , globalDLandscape02Vtx };

export { zn17btTypedConstraint21setupSolverConstraintER20btAlignedObjectArrayI18btSolverConstraintEiif };

export { zn17btTypedConstraint23solveConstraintObsoleteER11btRigidBodyS1F };

export { globalDz6mymainiPPc, zn14BenchmarkDemo4D1Ev, zn14BenchmarkDemo4D0Ev, draw, initNew };

export { zn15btNullPairCache23getOverlappingPairArrayEv };

export { zn15btNullPairCache20cleanOverlappingPairER16btBroadphasePairP12btDispatcher };

export { znk15btNullPairCache22getNumOverlappingPairsEv };

export { zn15btNullPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcher };

export { zn15btNullPairCache24setOverlapFilterCallbackEP23btOverlapFilterCallback };

export { zn15btNullPairCache26processAllOverlappingPairsEP17btOverlapCallbackP12btDispatcher };

export { zn15btNullPairCache8findPairEP17btBroadphaseProxyS1, zn15btNullPairCache18hasDeferredRemovalEv };

export { zn15btNullPairCache28setInternalGhostPairCallbackEP25btOverlappingPairCallback };

export { zn15btNullPairCache18addOverlappingPairEP17btBroadphaseProxyS1 };

export { zn15btNullPairCache21removeOverlappingPairEP17btBroadphaseProxyS1P12btDispatcher };

export { zn15btNullPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcher };

export { zn15btNullPairCache20sortOverlappingPairsEP12btDispatcher, zn15btNullPairCache26getOverlappingPairArrayPtrEv };

export { znk15btNullPairCache26getOverlappingPairArrayPtrEv, zn15btNullPairCacheD1Ev, zn15btNullPairCacheD0Ev };

export { znk20btAxisSweep3InternalItE7getAabbEP17btBroadphaseProxyR9btVector3S4 };

export { zn20btAxisSweep3InternalItE23getOverlappingPairCacheEv, znk20btAxisSweep3InternalItE23getOverlappingPairCacheEv };

export { znk20btAxisSweep3InternalItE17getBroadphaseAabbER9btVector3S2 };

export { zn20btAxisSweep3InternalItE9resetPoolEP12btDispatcher, zn20btAxisSweep3InternalItE10printStatsEv };

export { zn20btAxisSweep3InternalItE8aabbTestERK9btVector3S3R24btBroadphaseAabbCallback };

export { zn20btAxisSweep3InternalItE7rayTestERK9btVector3S3R23btBroadphaseRayCallbackS3S3 };

export { zn20btAxisSweep3InternalItE7setAabbEP17btBroadphaseProxyRK9btVector3S5P12btDispatcher };

export {
  zn20btAxisSweep3InternalItE12destroyProxyEP17btBroadphaseProxyP12btDispatcher,
  nullMandreelAudio,
  mandreelStartAudio,
  waInitWebAudio,
  mandreelWebAudioPreloadAssets,
  variableSet,
  WebkitAudioContext
};

export {
  GmandreelFs,
  navigator,
  mandreelAudioInit,
  mandreelAudioEnd,
  mandreelAudioUpdate,
  mandreelAudioCreateBuffer,
  mandreelAudioPlayChannel,
  mandreelAudioStopChannel,
  mandreelAudioSetChannelVolume,
  mandreelAudioSetChannelPan,
  mandreelAudioSetChannelPitch,
  mandreelAudioUseMusicFunctionsNew
};
